void mycs(double c[3][3][3], double mxyz[3]) {
  double m1, m2, m[4][3], t0, t1, t2;
  int cn;
  m1 = c[0][1][0] + c[0][1][2] + c[0][0][1] + c[0][2][1] + c[0][1][1];
  m2 = c[2][1][0] + c[2][1][2] + c[2][0][1] + c[2][2][1] + c[2][1][1];
  m[0][0] = m1 > m2 ? 1. : -1.;
  m1 = c[0][0][1] + c[2][0][1] + c[1][0][1];
  m2 = c[0][2][1] + c[2][2][1] + c[1][2][1];
  m[0][1] = 0.5 * (m1 - m2);
  m1 = c[0][1][0] + c[2][1][0] + c[1][1][0];
  m2 = c[0][1][2] + c[2][1][2] + c[1][1][2];
  m[0][2] = 0.5 * (m1 - m2);
  m1 = c[0][0][1] + c[0][2][1] + c[0][1][1];
  m2 = c[2][0][1] + c[2][2][1] + c[2][1][1];
  m[1][0] = 0.5 * (m1 - m2);
  m1 = c[1][0][0] + c[1][0][2] + c[2][0][1] + c[0][0][1] + c[1][0][1];
  m2 = c[1][2][0] + c[1][2][2] + c[2][2][1] + c[0][2][1] + c[1][2][1];
  m[1][1] = m1 > m2 ? 1. : -1.;
  m1 = c[1][0][0] + c[1][1][0] + c[1][2][0];
  m2 = c[1][0][2] + c[1][1][2] + c[1][2][2];
  m[1][2] = 0.5 * (m1 - m2);
  m1 = c[0][1][0] + c[0][1][2] + c[0][1][1];
  m2 = c[2][1][0] + c[2][1][2] + c[2][1][1];
  m[2][0] = 0.5 * (m1 - m2);
  m1 = c[1][0][0] + c[1][0][2] + c[1][0][1];
  m2 = c[1][2][0] + c[1][2][2] + c[1][2][1];
  m[2][1] = 0.5 * (m1 - m2);
  m1 = c[0][1][0] + c[2][1][0] + c[1][0][0] + c[1][2][0] + c[1][1][0];
  m2 = c[0][1][2] + c[2][1][2] + c[1][0][2] + c[1][2][2] + c[1][1][2];
  m[2][2] = m1 > m2 ? 1. : -1.;
  t0 = fabs(m[0][0]) + fabs(m[0][1]) + fabs(m[0][2]);
  m[0][0] /= t0;
  m[0][1] /= t0;
  m[0][2] /= t0;
  t0 = fabs(m[1][0]) + fabs(m[1][1]) + fabs(m[1][2]);
  m[1][0] /= t0;
  m[1][1] /= t0;
  m[1][2] /= t0;
  t0 = fabs(m[2][0]) + fabs(m[2][1]) + fabs(m[2][2]);
  m[2][0] /= t0;
  m[2][1] /= t0;
  m[2][2] /= t0;
  t0 = fabs(m[0][0]);
  t1 = fabs(m[1][1]);
  t2 = fabs(m[2][2]);
  cn = 0;
  if (t1 > t0) {
    t0 = t1;
    cn = 1;
  }
  if (t2 > t0)
    cn = 2;
  m1 = c[0][0][0] + c[0][2][0] + c[0][0][2] + c[0][2][2] +
       2. * (c[0][0][1] + c[0][2][1] + c[0][1][0] + c[0][1][2]) +
       4. * c[0][1][1];
  m2 = c[2][0][0] + c[2][2][0] + c[2][0][2] + c[2][2][2] +
       2. * (c[2][0][1] + c[2][2][1] + c[2][1][0] + c[2][1][2]) +
       4. * c[2][1][1];
  m[3][0] = m1 - m2;
  m1 = c[0][0][0] + c[0][0][2] + c[2][0][0] + c[2][0][2] +
       2. * (c[0][0][1] + c[2][0][1] + c[1][0][0] + c[1][0][2]) +
       4. * c[1][0][1];
  m2 = c[0][2][0] + c[0][2][2] + c[2][2][0] + c[2][2][2] +
       2. * (c[0][2][1] + c[2][2][1] + c[1][2][0] + c[1][2][2]) +
       4. * c[1][2][1];
  m[3][1] = m1 - m2;
  m1 = c[0][0][0] + c[0][2][0] + c[2][0][0] + c[2][2][0] +
       2. * (c[0][1][0] + c[2][1][0] + c[1][0][0] + c[1][2][0]) +
       4. * c[1][1][0];
  m2 = c[0][0][2] + c[0][2][2] + c[2][0][2] + c[2][2][2] +
       2. * (c[0][1][2] + c[2][1][2] + c[1][0][2] + c[1][2][2]) +
       4. * c[1][1][2];
  m[3][2] = m1 - m2;
  t0 = fabs(m[3][0]) + fabs(m[3][1]) + fabs(m[3][2]) + 1.e-30;
  m[3][0] /= t0;
  m[3][1] /= t0;
  m[3][2] /= t0;
  t0 = fabs(m[3][0]);
  t1 = fabs(m[3][1]);
  t2 = fabs(m[3][2]);
  if (t1 > t0)
    t0 = t1;
  if (t2 > t0)
    t0 = t2;
  if (fabs(m[cn][cn]) > t0)
    cn = 3;
  mxyz[0] = m[cn][0];
  mxyz[1] = m[cn][1];
  mxyz[2] = m[cn][2];
  return;
}


x86 assembly (clang, -O0):
<mycs>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0x28(%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0x38(%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0x20(%rax),%xmm0
movsd  %xmm0,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movsd  0xa8(%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0xb8(%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0x98(%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0xc8(%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0xb0(%rax),%xmm0
movsd  %xmm0,-0x20(%rbp)
movsd  -0x18(%rbp),%xmm1
movsd  -0x20(%rbp),%xmm0
movsd  0xe7b(%rip),%xmm3
movsd  0xe7b(%rip),%xmm2
cmpltsd %xmm1,%xmm0
movaps %xmm0,%xmm1
andpd  %xmm3,%xmm1
andnpd %xmm2,%xmm0
orpd   %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0x98(%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0x50(%rax),%xmm0
movsd  %xmm0,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x38(%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0xc8(%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0x80(%rax),%xmm0
movsd  %xmm0,-0x20(%rbp)
movsd  -0x18(%rbp),%xmm1
subsd  -0x20(%rbp),%xmm1
movsd  0xe0f(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0xa8(%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0x60(%rax),%xmm0
movsd  %xmm0,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0xb8(%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0x70(%rax),%xmm0
movsd  %xmm0,-0x20(%rbp)
movsd  -0x18(%rbp),%xmm1
subsd  -0x20(%rbp),%xmm1
movsd  0xdae(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0x38(%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0x20(%rax),%xmm0
movsd  %xmm0,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x98(%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0xc8(%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0xb0(%rax),%xmm0
movsd  %xmm0,-0x20(%rbp)
movsd  -0x18(%rbp),%xmm1
subsd  -0x20(%rbp),%xmm1
movsd  0xd4a(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x48(%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0x58(%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0x98(%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0x50(%rax),%xmm0
movsd  %xmm0,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x78(%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0x88(%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0xc8(%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0x38(%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0x80(%rax),%xmm0
movsd  %xmm0,-0x20(%rbp)
movsd  -0x18(%rbp),%xmm1
movsd  -0x20(%rbp),%xmm0
movsd  0xcaf(%rip),%xmm3
movsd  0xcaf(%rip),%xmm2
cmpltsd %xmm1,%xmm0
movaps %xmm0,%xmm1
andpd  %xmm3,%xmm1
andnpd %xmm2,%xmm0
orpd   %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x48(%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0x60(%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0x78(%rax),%xmm0
movsd  %xmm0,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x58(%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0x70(%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0x88(%rax),%xmm0
movsd  %xmm0,-0x20(%rbp)
movsd  -0x18(%rbp),%xmm1
subsd  -0x20(%rbp),%xmm1
movsd  0xc49(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0x28(%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0x20(%rax),%xmm0
movsd  %xmm0,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movsd  0xa8(%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0xb8(%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0xb0(%rax),%xmm0
movsd  %xmm0,-0x20(%rbp)
movsd  -0x18(%rbp),%xmm1
subsd  -0x20(%rbp),%xmm1
movsd  0xbe5(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x48(%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0x58(%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0x50(%rax),%xmm0
movsd  %xmm0,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x78(%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0x88(%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0x80(%rax),%xmm0
movsd  %xmm0,-0x20(%rbp)
movsd  -0x18(%rbp),%xmm1
subsd  -0x20(%rbp),%xmm1
movsd  0xb84(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0xa8(%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0x48(%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0x78(%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0x60(%rax),%xmm0
movsd  %xmm0,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0xb8(%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0x58(%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0x88(%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0x70(%rax),%xmm0
movsd  %xmm0,-0x20(%rbp)
movsd  -0x18(%rbp),%xmm1
movsd  -0x20(%rbp),%xmm0
movsd  0xaec(%rip),%xmm3
movsd  0xaec(%rip),%xmm2
cmpltsd %xmm1,%xmm0
movaps %xmm0,%xmm1
andpd  %xmm3,%xmm1
andnpd %xmm2,%xmm0
orpd   %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x80(%rbp),%xmm0
movaps 0xaaf(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  -0x78(%rbp),%xmm1
movaps 0xa9f(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  -0x70(%rbp),%xmm1
movaps 0xa8b(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0x80(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0x78(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0x70(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x68(%rbp),%xmm0
movaps 0xa2d(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  -0x60(%rbp),%xmm1
movaps 0xa1d(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  -0x58(%rbp),%xmm1
movaps 0xa09(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0x68(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0x60(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0x58(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x50(%rbp),%xmm0
movaps 0x9ab(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  -0x48(%rbp),%xmm1
movaps 0x99b(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  -0x40(%rbp),%xmm1
movaps 0x987(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0x50(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0x48(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0x40(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x80(%rbp),%xmm0
movaps 0x929(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movaps 0x911(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x40(%rbp),%xmm0
movaps 0x8f9(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movl   $0x0,-0x9c(%rbp)
movsd  -0x90(%rbp),%xmm0
ff
ucomisd -0x88(%rbp),%xmm0
ff
jbe    174d <mycs+0x64d>
movsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
movl   $0x1,-0x9c(%rbp)
movsd  -0x98(%rbp),%xmm0
ff
ucomisd -0x88(%rbp),%xmm0
ff
jbe    176d <mycs+0x66d>
movl   $0x2,-0x9c(%rbp)
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0x30(%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0x10(%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0x40(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x8(%rbp),%rax
addsd  0x38(%rax),%xmm1
mov    -0x8(%rbp),%rax
addsd  0x18(%rax),%xmm1
mov    -0x8(%rbp),%rax
addsd  0x28(%rax),%xmm1
addsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm0
movsd  0x863(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x90(%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0xc0(%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0xa0(%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0xd0(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x98(%rax),%xmm1
mov    -0x8(%rbp),%rax
addsd  0xc8(%rax),%xmm1
mov    -0x8(%rbp),%rax
addsd  0xa8(%rax),%xmm1
mov    -0x8(%rbp),%rax
addsd  0xb8(%rax),%xmm1
addsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0xb0(%rax),%xmm0
movsd  0x7da(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x20(%rbp)
movsd  -0x18(%rbp),%xmm0
subsd  -0x20(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0x10(%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0x90(%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0xa0(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x8(%rbp),%rax
addsd  0x98(%rax),%xmm1
mov    -0x8(%rbp),%rax
addsd  0x48(%rax),%xmm1
mov    -0x8(%rbp),%rax
addsd  0x58(%rax),%xmm1
addsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x50(%rax),%xmm0
movsd  0x755(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x30(%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0x40(%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0xc0(%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0xd0(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x38(%rax),%xmm1
mov    -0x8(%rbp),%rax
addsd  0xc8(%rax),%xmm1
mov    -0x8(%rbp),%rax
addsd  0x78(%rax),%xmm1
mov    -0x8(%rbp),%rax
addsd  0x88(%rax),%xmm1
addsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x80(%rax),%xmm0
movsd  0x6d8(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x20(%rbp)
movsd  -0x18(%rbp),%xmm0
subsd  -0x20(%rbp),%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0x30(%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0x90(%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0xc0(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm1
mov    -0x8(%rbp),%rax
addsd  0xa8(%rax),%xmm1
mov    -0x8(%rbp),%rax
addsd  0x48(%rax),%xmm1
mov    -0x8(%rbp),%rax
addsd  0x78(%rax),%xmm1
addsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x60(%rax),%xmm0
movsd  0x653(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0x40(%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0xa0(%rax),%xmm0
mov    -0x8(%rbp),%rax
addsd  0xd0(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm1
mov    -0x8(%rbp),%rax
addsd  0xb8(%rax),%xmm1
mov    -0x8(%rbp),%rax
addsd  0x58(%rax),%xmm1
mov    -0x8(%rbp),%rax
addsd  0x88(%rax),%xmm1
addsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x70(%rax),%xmm0
movsd  0x5d9(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x20(%rbp)
movsd  -0x18(%rbp),%xmm0
subsd  -0x20(%rbp),%xmm0
movsd  %xmm0,-0x28(%rbp)
movsd  -0x38(%rbp),%xmm0
movaps 0x581(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  -0x30(%rbp),%xmm1
movaps 0x571(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  -0x28(%rbp),%xmm1
movaps 0x55d(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  0x575(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0x38(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0x30(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x30(%rbp)
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0x28(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x28(%rbp)
movsd  -0x38(%rbp),%xmm0
movaps 0x4f3(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x30(%rbp),%xmm0
movaps 0x4db(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x28(%rbp),%xmm0
movaps 0x4c3(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
ucomisd -0x88(%rbp),%xmm0
ff
jbe    1b6f <mycs+0xa6f>
movsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
ucomisd -0x88(%rbp),%xmm0
ff
jbe    1b95 <mycs+0xa95>
movsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
movslq -0x9c(%rbp),%rcx
lea    -0x80(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x9c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x446(%rip),%xmm1
pand   %xmm1,%xmm0
ucomisd -0x88(%rbp),%xmm0
ff
jbe    1bd6 <mycs+0xad6>
movl   $0x3,-0x9c(%rbp)
movslq -0x9c(%rbp),%rcx
lea    -0x80(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,(%rax)
movslq -0x9c(%rbp),%rcx
lea    -0x80(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movslq -0x9c(%rbp),%rcx
lea    -0x80(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x10(%rax)
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<mycs>:
sub    $0xb8,%rsp
movsd  0x8(%rdi),%xmm11
movsd  0x38(%rdi),%xmm1
movsd  0x18(%rdi),%xmm5
movsd  0xa8(%rdi),%xmm6
movapd %xmm5,%xmm12
unpcklpd %xmm6,%xmm12
movsd  0x28(%rdi),%xmm2
movsd  0xb8(%rdi),%xmm0
movapd %xmm2,%xmm3
unpcklpd %xmm0,%xmm3
movapd %xmm3,%xmm10
movapd %xmm3,0x20(%rsp)
movsd  0x98(%rdi),%xmm9
movsd  0xc8(%rdi),%xmm7
movsd  0xb0(%rdi),%xmm4
movapd %xmm1,%xmm3
addsd  %xmm7,%xmm3
movapd %xmm3,%xmm15
movapd %xmm3,%xmm14
unpcklpd %xmm11,%xmm5
unpcklpd %xmm1,%xmm6
addpd  %xmm5,%xmm6
unpcklpd %xmm9,%xmm2
movapd %xmm0,%xmm3
unpcklpd %xmm7,%xmm3
movapd %xmm7,%xmm0
addpd  %xmm2,%xmm3
movsd  0x70(%rdi),%xmm5
movapd %xmm5,-0x80(%rsp)
unpcklpd %xmm4,%xmm5
movapd %xmm4,%xmm13
movapd %xmm4,-0x20(%rsp)
addpd  %xmm3,%xmm5
unpcklpd %xmm3,%xmm14
movapd %xmm14,0x40(%rsp)
movapd %xmm6,%xmm4
movapd %xmm6,-0x30(%rsp)
movhlps %xmm6,%xmm3
addpd  %xmm12,%xmm3
movapd %xmm3,0x30(%rsp)
addpd  %xmm10,%xmm12
movapd %xmm11,%xmm2
unpcklpd %xmm9,%xmm2
addpd  %xmm12,%xmm2
movapd %xmm12,%xmm6
movapd %xmm12,-0x60(%rsp)
movapd %xmm11,%xmm8
unpcklpd %xmm1,%xmm11
unpcklpd %xmm7,%xmm1
addpd  %xmm2,%xmm1
movsd  0x20(%rdi),%xmm3
movapd %xmm3,%xmm2
movapd %xmm3,%xmm7
movapd %xmm3,-0x40(%rsp)
unpcklpd %xmm13,%xmm2
movapd %xmm2,0x10(%rsp)
addpd  %xmm2,%xmm1
movapd %xmm1,%xmm10
unpckhpd %xmm1,%xmm10
cmpltsd %xmm1,%xmm10
movsd  0xdbc(%rip),%xmm2
movapd %xmm10,%xmm1
andpd  %xmm2,%xmm1
movsd  0xdb3(%rip),%xmm2
andnpd %xmm2,%xmm10
orpd   %xmm1,%xmm10
movapd %xmm8,%xmm1
addsd  %xmm9,%xmm1
movapd %xmm1,-0x10(%rsp)
movsd  0x50(%rdi),%xmm3
addsd  %xmm3,%xmm1
movsd  0x80(%rdi),%xmm2
addsd  %xmm2,%xmm15
movapd %xmm2,%xmm14
subsd  %xmm15,%xmm1
movupd 0x58(%rdi),%xmm8
movapd %xmm8,%xmm15
shufpd $0x1,%xmm7,%xmm15
addpd  %xmm4,%xmm15
subpd  %xmm5,%xmm15
movsd  0x48(%rdi),%xmm5
movsd  0x78(%rdi),%xmm4
movapd %xmm5,%xmm2
unpcklpd %xmm4,%xmm2
movsd  0x88(%rdi),%xmm13
movapd %xmm8,%xmm12
unpcklpd %xmm13,%xmm12
addpd  %xmm2,%xmm12
unpcklpd %xmm0,%xmm9
addpd  %xmm12,%xmm9
movapd %xmm11,%xmm7
addpd  %xmm9,%xmm7
movapd -0x80(%rsp),%xmm2
unpcklpd %xmm5,%xmm2
addpd  %xmm8,%xmm2
movapd %xmm13,%xmm11
unpcklpd %xmm4,%xmm11
unpcklpd %xmm3,%xmm6
movapd %xmm6,-0x70(%rsp)
movapd %xmm8,%xmm9
unpcklpd %xmm4,%xmm9
unpcklpd %xmm8,%xmm4
movapd %xmm8,-0x50(%rsp)
movsd  %xmm3,%xmm8
movapd %xmm14,%xmm0
movapd %xmm14,(%rsp)
unpcklpd %xmm14,%xmm3
addpd  %xmm7,%xmm3
movapd %xmm3,%xmm6
unpckhpd %xmm3,%xmm6
cmpltsd %xmm3,%xmm6
movapd %xmm6,%xmm3
movsd  0xcac(%rip),%xmm14
andpd  %xmm14,%xmm3
movsd  0xca7(%rip),%xmm7
andnpd %xmm7,%xmm6
orpd   %xmm3,%xmm6
addpd  %xmm2,%xmm11
movapd %xmm11,%xmm3
unpckhpd %xmm11,%xmm3
subsd  %xmm11,%xmm3
movsd  0xc8b(%rip),%xmm2
mulsd  %xmm2,%xmm1
mulsd  %xmm2,%xmm3
movapd -0x40(%rsp),%xmm14
unpcklpd %xmm12,%xmm14
addpd  -0x70(%rsp),%xmm14
movlpd -0x20(%rsp),%xmm12
movapd -0x60(%rsp),%xmm2
shufpd $0x1,%xmm0,%xmm2
addpd  %xmm2,%xmm12
subpd  %xmm12,%xmm14
movapd 0xc5c(%rip),%xmm2
mulpd  %xmm2,%xmm15
mulpd  %xmm2,%xmm14
movapd -0x10(%rsp),%xmm0
unpcklpd -0x30(%rsp),%xmm0
unpcklpd %xmm5,%xmm5
addpd  %xmm0,%xmm5
addpd  %xmm5,%xmm9
addpd  0x40(%rsp),%xmm4
unpcklpd %xmm13,%xmm13
addpd  %xmm4,%xmm13
movapd -0x50(%rsp),%xmm0
shufpd $0x1,-0x80(%rsp),%xmm0
movapd %xmm9,%xmm2
unpckhpd %xmm13,%xmm2
addpd  %xmm0,%xmm2
movapd %xmm2,%xmm7
unpckhpd %xmm2,%xmm7
cmpltsd %xmm2,%xmm7
movsd  0xbd9(%rip),%xmm0
andpd  %xmm7,%xmm0
movsd  0xbd5(%rip),%xmm2
andnpd %xmm2,%xmm7
orpd   %xmm0,%xmm7
movapd %xmm15,%xmm4
movsd  %xmm1,%xmm4
movapd 0xbe4(%rip),%xmm0
andpd  %xmm0,%xmm4
addpd  0xbe8(%rip),%xmm4
movapd %xmm15,%xmm5
unpcklpd %xmm3,%xmm5
andpd  %xmm0,%xmm5
addpd  %xmm4,%xmm5
unpcklpd %xmm1,%xmm10
movapd %xmm5,%xmm4
unpcklpd %xmm5,%xmm4
divpd  %xmm4,%xmm10
movapd %xmm10,0x50(%rsp)
divpd  %xmm5,%xmm15
movapd %xmm15,0x60(%rsp)
unpcklpd %xmm3,%xmm6
unpckhpd %xmm5,%xmm5
divpd  %xmm5,%xmm6
movapd %xmm6,0x70(%rsp)
movsd  (%rdi),%xmm0
movsd  0x10(%rdi),%xmm3
movsd  0x30(%rdi),%xmm12
unpcklpd %xmm0,%xmm0
movapd %xmm3,%xmm5
unpcklpd %xmm12,%xmm5
addpd  %xmm0,%xmm5
movsd  0x90(%rdi),%xmm4
movsd  0xc0(%rdi),%xmm15
movapd %xmm4,%xmm0
addsd  %xmm15,%xmm0
unpcklpd %xmm4,%xmm4
addpd  %xmm5,%xmm4
shufpd $0x1,%xmm0,%xmm5
unpcklpd %xmm3,%xmm12
movsd  0xa0(%rdi),%xmm11
unpcklpd %xmm11,%xmm3
addpd  %xmm5,%xmm3
movsd  0x40(%rdi),%xmm1
movsd  0xd0(%rdi),%xmm2
movapd %xmm1,%xmm5
unpcklpd %xmm2,%xmm5
addpd  %xmm3,%xmm5
movapd 0x30(%rsp),%xmm3
addpd  0x20(%rsp),%xmm3
addpd  %xmm3,%xmm3
addpd  %xmm5,%xmm3
movapd %xmm3,%xmm5
movapd 0xb19(%rip),%xmm3
movapd 0x10(%rsp),%xmm0
mulpd  %xmm3,%xmm0
addpd  %xmm5,%xmm0
movapd %xmm0,%xmm5
unpckhpd %xmm0,%xmm5
subpd  %xmm5,%xmm0
movapd %xmm11,%xmm5
unpcklpd %xmm15,%xmm5
addpd  %xmm4,%xmm5
addpd  %xmm9,%xmm9
addpd  %xmm5,%xmm9
mulpd  %xmm3,%xmm8
addpd  %xmm9,%xmm8
unpcklpd %xmm1,%xmm1
addpd  %xmm12,%xmm1
unpcklpd %xmm11,%xmm15
addpd  %xmm1,%xmm15
unpcklpd %xmm2,%xmm2
addpd  %xmm15,%xmm2
addpd  %xmm13,%xmm13
addpd  %xmm2,%xmm13
movapd (%rsp),%xmm1
unpcklpd -0x80(%rsp),%xmm1
mulpd  %xmm3,%xmm1
addpd  %xmm13,%xmm1
subpd  %xmm1,%xmm8
unpcklpd %xmm0,%xmm7
movapd 0xa72(%rip),%xmm1
andpd  %xmm1,%xmm0
movapd %xmm8,%xmm2
andpd  %xmm1,%xmm2
addsd  %xmm0,%xmm2
movapd %xmm14,%xmm0
unpckhpd %xmm14,%xmm0
andpd  %xmm1,%xmm0
unpcklpd %xmm2,%xmm0
movapd %xmm8,%xmm2
movsd  %xmm14,%xmm2
andpd  %xmm1,%xmm2
addpd  %xmm0,%xmm2
addpd  0xa65(%rip),%xmm2
andpd  %xmm1,%xmm10
andpd  %xmm1,%xmm6
xor    %eax,%eax
ucomisd %xmm10,%xmm6
divpd  %xmm2,%xmm7
maxsd  %xmm10,%xmm6
movapd %xmm7,%xmm0
seta   %al
andpd  %xmm1,%xmm0
ucomisd %xmm6,%xmm0
movapd %xmm2,%xmm0
unpcklpd %xmm2,%xmm0
divpd  %xmm0,%xmm14
movapd %xmm14,0x80(%rsp)
movapd %xmm7,0x90(%rsp)
unpckhpd %xmm2,%xmm2
divpd  %xmm2,%xmm8
movsd  %xmm8,%xmm7
andpd  %xmm1,%xmm7
pshufd $0xee,%xmm7,%xmm0
maxsd  %xmm0,%xmm7
movapd %xmm8,0xa0(%rsp)
unpckhpd %xmm8,%xmm8
andpd  %xmm1,%xmm8
mov    $0x2,%ecx
cmovbe %rax,%rcx
maxsd  %xmm7,%xmm8
lea    (%rcx,%rcx,2),%rax
lea    (%rsp,%rax,8),%rax
add    $0x50,%rax
movsd  (%rax,%rcx,8),%xmm0
andpd  %xmm1,%xmm0
ucomisd %xmm8,%xmm0
mov    $0x3,%eax
cmovbe %rcx,%rax
lea    (%rax,%rax,2),%rax
movups 0x50(%rsp,%rax,8),%xmm0
movups %xmm0,(%rsi)
movsd  0x60(%rsp,%rax,8),%xmm0
movsd  %xmm0,0x10(%rsi)
add    $0xb8,%rsp
ret

LLVM IR (-O0):
define void @mycs([3 x [3 x double]]* %0, double* %1) {
%3 = alloca [3 x [3 x double]]*
%4 = alloca double*
%5 = alloca double
%6 = alloca double
%7 = alloca [4 x [3 x double]]
%8 = alloca double
%9 = alloca double
%10 = alloca double
%11 = alloca i32
store [3 x [3 x double]]* %0, [3 x [3 x double]]** %3
store double* %1, double** %4
%12 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%13 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %12, i64 0
%14 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %13, i64 0, i64 1
%15 = getelementptr inbounds [3 x double], [3 x double]* %14, i64 0, i64 0
%16 = load double, double* %15
%17 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%18 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %17, i64 0
%19 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %18, i64 0, i64 1
%20 = getelementptr inbounds [3 x double], [3 x double]* %19, i64 0, i64 2
%21 = load double, double* %20
%22 = fadd double %16, %21
%23 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%24 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %23, i64 0
%25 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %24, i64 0, i64 0
%26 = getelementptr inbounds [3 x double], [3 x double]* %25, i64 0, i64 1
%27 = load double, double* %26
%28 = fadd double %22, %27
%29 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%30 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %29, i64 0
%31 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %30, i64 0, i64 2
%32 = getelementptr inbounds [3 x double], [3 x double]* %31, i64 0, i64 1
%33 = load double, double* %32
%34 = fadd double %28, %33
%35 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%36 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %35, i64 0
%37 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %36, i64 0, i64 1
%38 = getelementptr inbounds [3 x double], [3 x double]* %37, i64 0, i64 1
%39 = load double, double* %38
%40 = fadd double %34, %39
store double %40, double* %5
%41 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%42 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %41, i64 2
%43 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %42, i64 0, i64 1
%44 = getelementptr inbounds [3 x double], [3 x double]* %43, i64 0, i64 0
%45 = load double, double* %44
%46 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%47 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %46, i64 2
%48 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %47, i64 0, i64 1
%49 = getelementptr inbounds [3 x double], [3 x double]* %48, i64 0, i64 2
%50 = load double, double* %49
%51 = fadd double %45, %50
%52 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%53 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %52, i64 2
%54 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %53, i64 0, i64 0
%55 = getelementptr inbounds [3 x double], [3 x double]* %54, i64 0, i64 1
%56 = load double, double* %55
%57 = fadd double %51, %56
%58 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%59 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %58, i64 2
%60 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %59, i64 0, i64 2
%61 = getelementptr inbounds [3 x double], [3 x double]* %60, i64 0, i64 1
%62 = load double, double* %61
%63 = fadd double %57, %62
%64 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%65 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %64, i64 2
%66 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %65, i64 0, i64 1
%67 = getelementptr inbounds [3 x double], [3 x double]* %66, i64 0, i64 1
%68 = load double, double* %67
%69 = fadd double %63, %68
store double %69, double* %6
%70 = load double, double* %5
%71 = load double, double* %6
%72 = fcmp ogt double %70, %71
%73 = zext i1 %72 to i64
%74 = select i1 %72, double 1.000000e+00, double -1.000000e+00
%75 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %7, i64 0, i64 0
%76 = getelementptr inbounds [3 x double], [3 x double]* %75, i64 0, i64 0
store double %74, double* %76
%77 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%78 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %77, i64 0
%79 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %78, i64 0, i64 0
%80 = getelementptr inbounds [3 x double], [3 x double]* %79, i64 0, i64 1
%81 = load double, double* %80
%82 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%83 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %82, i64 2
%84 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %83, i64 0, i64 0
%85 = getelementptr inbounds [3 x double], [3 x double]* %84, i64 0, i64 1
%86 = load double, double* %85
%87 = fadd double %81, %86
%88 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%89 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %88, i64 1
%90 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %89, i64 0, i64 0
%91 = getelementptr inbounds [3 x double], [3 x double]* %90, i64 0, i64 1
%92 = load double, double* %91
%93 = fadd double %87, %92
store double %93, double* %5
%94 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%95 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %94, i64 0
%96 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %95, i64 0, i64 2
%97 = getelementptr inbounds [3 x double], [3 x double]* %96, i64 0, i64 1
%98 = load double, double* %97
%99 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%100 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %99, i64 2
%101 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %100, i64 0, i64 2
%102 = getelementptr inbounds [3 x double], [3 x double]* %101, i64 0, i64 1
%103 = load double, double* %102
%104 = fadd double %98, %103
%105 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%106 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %105, i64 1
%107 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %106, i64 0, i64 2
%108 = getelementptr inbounds [3 x double], [3 x double]* %107, i64 0, i64 1
%109 = load double, double* %108
%110 = fadd double %104, %109
store double %110, double* %6
%111 = load double, double* %5
%112 = load double, double* %6
%113 = fsub double %111, %112
%114 = fmul double 5.000000e-01, %113
%115 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %7, i64 0, i64 0
%116 = getelementptr inbounds [3 x double], [3 x double]* %115, i64 0, i64 1
store double %114, double* %116
%117 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%118 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %117, i64 0
%119 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %118, i64 0, i64 1
%120 = getelementptr inbounds [3 x double], [3 x double]* %119, i64 0, i64 0
%121 = load double, double* %120
%122 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%123 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %122, i64 2
%124 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %123, i64 0, i64 1
%125 = getelementptr inbounds [3 x double], [3 x double]* %124, i64 0, i64 0
%126 = load double, double* %125
%127 = fadd double %121, %126
%128 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%129 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %128, i64 1
%130 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %129, i64 0, i64 1
%131 = getelementptr inbounds [3 x double], [3 x double]* %130, i64 0, i64 0
%132 = load double, double* %131
%133 = fadd double %127, %132
store double %133, double* %5
%134 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%135 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %134, i64 0
%136 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %135, i64 0, i64 1
%137 = getelementptr inbounds [3 x double], [3 x double]* %136, i64 0, i64 2
%138 = load double, double* %137
%139 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%140 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %139, i64 2
%141 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %140, i64 0, i64 1
%142 = getelementptr inbounds [3 x double], [3 x double]* %141, i64 0, i64 2
%143 = load double, double* %142
%144 = fadd double %138, %143
%145 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%146 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %145, i64 1
%147 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %146, i64 0, i64 1
%148 = getelementptr inbounds [3 x double], [3 x double]* %147, i64 0, i64 2
%149 = load double, double* %148
%150 = fadd double %144, %149
store double %150, double* %6
%151 = load double, double* %5
%152 = load double, double* %6
%153 = fsub double %151, %152
%154 = fmul double 5.000000e-01, %153
%155 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %7, i64 0, i64 0
%156 = getelementptr inbounds [3 x double], [3 x double]* %155, i64 0, i64 2
store double %154, double* %156
%157 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%158 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %157, i64 0
%159 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %158, i64 0, i64 0
%160 = getelementptr inbounds [3 x double], [3 x double]* %159, i64 0, i64 1
%161 = load double, double* %160
%162 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%163 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %162, i64 0
%164 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %163, i64 0, i64 2
%165 = getelementptr inbounds [3 x double], [3 x double]* %164, i64 0, i64 1
%166 = load double, double* %165
%167 = fadd double %161, %166
%168 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%169 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %168, i64 0
%170 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %169, i64 0, i64 1
%171 = getelementptr inbounds [3 x double], [3 x double]* %170, i64 0, i64 1
%172 = load double, double* %171
%173 = fadd double %167, %172
store double %173, double* %5
%174 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%175 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %174, i64 2
%176 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %175, i64 0, i64 0
%177 = getelementptr inbounds [3 x double], [3 x double]* %176, i64 0, i64 1
%178 = load double, double* %177
%179 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%180 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %179, i64 2
%181 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %180, i64 0, i64 2
%182 = getelementptr inbounds [3 x double], [3 x double]* %181, i64 0, i64 1
%183 = load double, double* %182
%184 = fadd double %178, %183
%185 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%186 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %185, i64 2
%187 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %186, i64 0, i64 1
%188 = getelementptr inbounds [3 x double], [3 x double]* %187, i64 0, i64 1
%189 = load double, double* %188
%190 = fadd double %184, %189
store double %190, double* %6
%191 = load double, double* %5
%192 = load double, double* %6
%193 = fsub double %191, %192
%194 = fmul double 5.000000e-01, %193
%195 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %7, i64 0, i64 1
%196 = getelementptr inbounds [3 x double], [3 x double]* %195, i64 0, i64 0
store double %194, double* %196
%197 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%198 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %197, i64 1
%199 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %198, i64 0, i64 0
%200 = getelementptr inbounds [3 x double], [3 x double]* %199, i64 0, i64 0
%201 = load double, double* %200
%202 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%203 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %202, i64 1
%204 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %203, i64 0, i64 0
%205 = getelementptr inbounds [3 x double], [3 x double]* %204, i64 0, i64 2
%206 = load double, double* %205
%207 = fadd double %201, %206
%208 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%209 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %208, i64 2
%210 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %209, i64 0, i64 0
%211 = getelementptr inbounds [3 x double], [3 x double]* %210, i64 0, i64 1
%212 = load double, double* %211
%213 = fadd double %207, %212
%214 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%215 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %214, i64 0
%216 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %215, i64 0, i64 0
%217 = getelementptr inbounds [3 x double], [3 x double]* %216, i64 0, i64 1
%218 = load double, double* %217
%219 = fadd double %213, %218
%220 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%221 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %220, i64 1
%222 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %221, i64 0, i64 0
%223 = getelementptr inbounds [3 x double], [3 x double]* %222, i64 0, i64 1
%224 = load double, double* %223
%225 = fadd double %219, %224
store double %225, double* %5
%226 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%227 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %226, i64 1
%228 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %227, i64 0, i64 2
%229 = getelementptr inbounds [3 x double], [3 x double]* %228, i64 0, i64 0
%230 = load double, double* %229
%231 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%232 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %231, i64 1
%233 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %232, i64 0, i64 2
%234 = getelementptr inbounds [3 x double], [3 x double]* %233, i64 0, i64 2
%235 = load double, double* %234
%236 = fadd double %230, %235
%237 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%238 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %237, i64 2
%239 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %238, i64 0, i64 2
%240 = getelementptr inbounds [3 x double], [3 x double]* %239, i64 0, i64 1
%241 = load double, double* %240
%242 = fadd double %236, %241
%243 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%244 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %243, i64 0
%245 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %244, i64 0, i64 2
%246 = getelementptr inbounds [3 x double], [3 x double]* %245, i64 0, i64 1
%247 = load double, double* %246
%248 = fadd double %242, %247
%249 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%250 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %249, i64 1
%251 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %250, i64 0, i64 2
%252 = getelementptr inbounds [3 x double], [3 x double]* %251, i64 0, i64 1
%253 = load double, double* %252
%254 = fadd double %248, %253
store double %254, double* %6
%255 = load double, double* %5
%256 = load double, double* %6
%257 = fcmp ogt double %255, %256
%258 = zext i1 %257 to i64
%259 = select i1 %257, double 1.000000e+00, double -1.000000e+00
%260 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %7, i64 0, i64 1
%261 = getelementptr inbounds [3 x double], [3 x double]* %260, i64 0, i64 1
store double %259, double* %261
%262 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%263 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %262, i64 1
%264 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %263, i64 0, i64 0
%265 = getelementptr inbounds [3 x double], [3 x double]* %264, i64 0, i64 0
%266 = load double, double* %265
%267 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%268 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %267, i64 1
%269 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %268, i64 0, i64 1
%270 = getelementptr inbounds [3 x double], [3 x double]* %269, i64 0, i64 0
%271 = load double, double* %270
%272 = fadd double %266, %271
%273 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%274 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %273, i64 1
%275 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %274, i64 0, i64 2
%276 = getelementptr inbounds [3 x double], [3 x double]* %275, i64 0, i64 0
%277 = load double, double* %276
%278 = fadd double %272, %277
store double %278, double* %5
%279 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%280 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %279, i64 1
%281 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %280, i64 0, i64 0
%282 = getelementptr inbounds [3 x double], [3 x double]* %281, i64 0, i64 2
%283 = load double, double* %282
%284 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%285 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %284, i64 1
%286 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %285, i64 0, i64 1
%287 = getelementptr inbounds [3 x double], [3 x double]* %286, i64 0, i64 2
%288 = load double, double* %287
%289 = fadd double %283, %288
%290 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%291 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %290, i64 1
%292 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %291, i64 0, i64 2
%293 = getelementptr inbounds [3 x double], [3 x double]* %292, i64 0, i64 2
%294 = load double, double* %293
%295 = fadd double %289, %294
store double %295, double* %6
%296 = load double, double* %5
%297 = load double, double* %6
%298 = fsub double %296, %297
%299 = fmul double 5.000000e-01, %298
%300 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %7, i64 0, i64 1
%301 = getelementptr inbounds [3 x double], [3 x double]* %300, i64 0, i64 2
store double %299, double* %301
%302 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%303 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %302, i64 0
%304 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %303, i64 0, i64 1
%305 = getelementptr inbounds [3 x double], [3 x double]* %304, i64 0, i64 0
%306 = load double, double* %305
%307 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%308 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %307, i64 0
%309 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %308, i64 0, i64 1
%310 = getelementptr inbounds [3 x double], [3 x double]* %309, i64 0, i64 2
%311 = load double, double* %310
%312 = fadd double %306, %311
%313 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%314 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %313, i64 0
%315 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %314, i64 0, i64 1
%316 = getelementptr inbounds [3 x double], [3 x double]* %315, i64 0, i64 1
%317 = load double, double* %316
%318 = fadd double %312, %317
store double %318, double* %5
%319 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%320 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %319, i64 2
%321 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %320, i64 0, i64 1
%322 = getelementptr inbounds [3 x double], [3 x double]* %321, i64 0, i64 0
%323 = load double, double* %322
%324 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%325 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %324, i64 2
%326 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %325, i64 0, i64 1
%327 = getelementptr inbounds [3 x double], [3 x double]* %326, i64 0, i64 2
%328 = load double, double* %327
%329 = fadd double %323, %328
%330 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%331 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %330, i64 2
%332 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %331, i64 0, i64 1
%333 = getelementptr inbounds [3 x double], [3 x double]* %332, i64 0, i64 1
%334 = load double, double* %333
%335 = fadd double %329, %334
store double %335, double* %6
%336 = load double, double* %5
%337 = load double, double* %6
%338 = fsub double %336, %337
%339 = fmul double 5.000000e-01, %338
%340 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %7, i64 0, i64 2
%341 = getelementptr inbounds [3 x double], [3 x double]* %340, i64 0, i64 0
store double %339, double* %341
%342 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%343 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %342, i64 1
%344 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %343, i64 0, i64 0
%345 = getelementptr inbounds [3 x double], [3 x double]* %344, i64 0, i64 0
%346 = load double, double* %345
%347 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%348 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %347, i64 1
%349 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %348, i64 0, i64 0
%350 = getelementptr inbounds [3 x double], [3 x double]* %349, i64 0, i64 2
%351 = load double, double* %350
%352 = fadd double %346, %351
%353 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%354 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %353, i64 1
%355 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %354, i64 0, i64 0
%356 = getelementptr inbounds [3 x double], [3 x double]* %355, i64 0, i64 1
%357 = load double, double* %356
%358 = fadd double %352, %357
store double %358, double* %5
%359 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%360 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %359, i64 1
%361 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %360, i64 0, i64 2
%362 = getelementptr inbounds [3 x double], [3 x double]* %361, i64 0, i64 0
%363 = load double, double* %362
%364 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%365 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %364, i64 1
%366 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %365, i64 0, i64 2
%367 = getelementptr inbounds [3 x double], [3 x double]* %366, i64 0, i64 2
%368 = load double, double* %367
%369 = fadd double %363, %368
%370 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%371 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %370, i64 1
%372 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %371, i64 0, i64 2
%373 = getelementptr inbounds [3 x double], [3 x double]* %372, i64 0, i64 1
%374 = load double, double* %373
%375 = fadd double %369, %374
store double %375, double* %6
%376 = load double, double* %5
%377 = load double, double* %6
%378 = fsub double %376, %377
%379 = fmul double 5.000000e-01, %378
%380 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %7, i64 0, i64 2
%381 = getelementptr inbounds [3 x double], [3 x double]* %380, i64 0, i64 1
store double %379, double* %381
%382 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%383 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %382, i64 0
%384 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %383, i64 0, i64 1
%385 = getelementptr inbounds [3 x double], [3 x double]* %384, i64 0, i64 0
%386 = load double, double* %385
%387 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%388 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %387, i64 2
%389 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %388, i64 0, i64 1
%390 = getelementptr inbounds [3 x double], [3 x double]* %389, i64 0, i64 0
%391 = load double, double* %390
%392 = fadd double %386, %391
%393 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%394 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %393, i64 1
%395 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %394, i64 0, i64 0
%396 = getelementptr inbounds [3 x double], [3 x double]* %395, i64 0, i64 0
%397 = load double, double* %396
%398 = fadd double %392, %397
%399 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%400 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %399, i64 1
%401 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %400, i64 0, i64 2
%402 = getelementptr inbounds [3 x double], [3 x double]* %401, i64 0, i64 0
%403 = load double, double* %402
%404 = fadd double %398, %403
%405 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%406 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %405, i64 1
%407 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %406, i64 0, i64 1
%408 = getelementptr inbounds [3 x double], [3 x double]* %407, i64 0, i64 0
%409 = load double, double* %408
%410 = fadd double %404, %409
store double %410, double* %5
%411 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%412 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %411, i64 0
%413 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %412, i64 0, i64 1
%414 = getelementptr inbounds [3 x double], [3 x double]* %413, i64 0, i64 2
%415 = load double, double* %414
%416 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%417 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %416, i64 2
%418 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %417, i64 0, i64 1
%419 = getelementptr inbounds [3 x double], [3 x double]* %418, i64 0, i64 2
%420 = load double, double* %419
%421 = fadd double %415, %420
%422 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%423 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %422, i64 1
%424 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %423, i64 0, i64 0
%425 = getelementptr inbounds [3 x double], [3 x double]* %424, i64 0, i64 2
%426 = load double, double* %425
%427 = fadd double %421, %426
%428 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%429 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %428, i64 1
%430 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %429, i64 0, i64 2
%431 = getelementptr inbounds [3 x double], [3 x double]* %430, i64 0, i64 2
%432 = load double, double* %431
%433 = fadd double %427, %432
%434 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%435 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %434, i64 1
%436 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %435, i64 0, i64 1
%437 = getelementptr inbounds [3 x double], [3 x double]* %436, i64 0, i64 2
%438 = load double, double* %437
%439 = fadd double %433, %438
store double %439, double* %6
%440 = load double, double* %5
%441 = load double, double* %6
%442 = fcmp ogt double %440, %441
%443 = zext i1 %442 to i64
%444 = select i1 %442, double 1.000000e+00, double -1.000000e+00
%445 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %7, i64 0, i64 2
%446 = getelementptr inbounds [3 x double], [3 x double]* %445, i64 0, i64 2
store double %444, double* %446
%447 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %7, i64 0, i64 0
%448 = getelementptr inbounds [3 x double], [3 x double]* %447, i64 0, i64 0
%449 = load double, double* %448
%450 = call double @llvm.fabs.f64(double %449)
%451 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %7, i64 0, i64 0
%452 = getelementptr inbounds [3 x double], [3 x double]* %451, i64 0, i64 1
%453 = load double, double* %452
%454 = call double @llvm.fabs.f64(double %453)
%455 = fadd double %450, %454
%456 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %7, i64 0, i64 0
%457 = getelementptr inbounds [3 x double], [3 x double]* %456, i64 0, i64 2
%458 = load double, double* %457
%459 = call double @llvm.fabs.f64(double %458)
%460 = fadd double %455, %459
store double %460, double* %8
%461 = load double, double* %8
%462 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %7, i64 0, i64 0
%463 = getelementptr inbounds [3 x double], [3 x double]* %462, i64 0, i64 0
%464 = load double, double* %463
%465 = fdiv double %464, %461
store double %465, double* %463
%466 = load double, double* %8
%467 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %7, i64 0, i64 0
%468 = getelementptr inbounds [3 x double], [3 x double]* %467, i64 0, i64 1
%469 = load double, double* %468
%470 = fdiv double %469, %466
store double %470, double* %468
%471 = load double, double* %8
%472 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %7, i64 0, i64 0
%473 = getelementptr inbounds [3 x double], [3 x double]* %472, i64 0, i64 2
%474 = load double, double* %473
%475 = fdiv double %474, %471
store double %475, double* %473
%476 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %7, i64 0, i64 1
%477 = getelementptr inbounds [3 x double], [3 x double]* %476, i64 0, i64 0
%478 = load double, double* %477
%479 = call double @llvm.fabs.f64(double %478)
%480 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %7, i64 0, i64 1
%481 = getelementptr inbounds [3 x double], [3 x double]* %480, i64 0, i64 1
%482 = load double, double* %481
%483 = call double @llvm.fabs.f64(double %482)
%484 = fadd double %479, %483
%485 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %7, i64 0, i64 1
%486 = getelementptr inbounds [3 x double], [3 x double]* %485, i64 0, i64 2
%487 = load double, double* %486
%488 = call double @llvm.fabs.f64(double %487)
%489 = fadd double %484, %488
store double %489, double* %8
%490 = load double, double* %8
%491 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %7, i64 0, i64 1
%492 = getelementptr inbounds [3 x double], [3 x double]* %491, i64 0, i64 0
%493 = load double, double* %492
%494 = fdiv double %493, %490
store double %494, double* %492
%495 = load double, double* %8
%496 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %7, i64 0, i64 1
%497 = getelementptr inbounds [3 x double], [3 x double]* %496, i64 0, i64 1
%498 = load double, double* %497
%499 = fdiv double %498, %495
store double %499, double* %497
%500 = load double, double* %8
%501 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %7, i64 0, i64 1
%502 = getelementptr inbounds [3 x double], [3 x double]* %501, i64 0, i64 2
%503 = load double, double* %502
%504 = fdiv double %503, %500
store double %504, double* %502
%505 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %7, i64 0, i64 2
%506 = getelementptr inbounds [3 x double], [3 x double]* %505, i64 0, i64 0
%507 = load double, double* %506
%508 = call double @llvm.fabs.f64(double %507)
%509 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %7, i64 0, i64 2
%510 = getelementptr inbounds [3 x double], [3 x double]* %509, i64 0, i64 1
%511 = load double, double* %510
%512 = call double @llvm.fabs.f64(double %511)
%513 = fadd double %508, %512
%514 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %7, i64 0, i64 2
%515 = getelementptr inbounds [3 x double], [3 x double]* %514, i64 0, i64 2
%516 = load double, double* %515
%517 = call double @llvm.fabs.f64(double %516)
%518 = fadd double %513, %517
store double %518, double* %8
%519 = load double, double* %8
%520 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %7, i64 0, i64 2
%521 = getelementptr inbounds [3 x double], [3 x double]* %520, i64 0, i64 0
%522 = load double, double* %521
%523 = fdiv double %522, %519
store double %523, double* %521
%524 = load double, double* %8
%525 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %7, i64 0, i64 2
%526 = getelementptr inbounds [3 x double], [3 x double]* %525, i64 0, i64 1
%527 = load double, double* %526
%528 = fdiv double %527, %524
store double %528, double* %526
%529 = load double, double* %8
%530 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %7, i64 0, i64 2
%531 = getelementptr inbounds [3 x double], [3 x double]* %530, i64 0, i64 2
%532 = load double, double* %531
%533 = fdiv double %532, %529
store double %533, double* %531
%534 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %7, i64 0, i64 0
%535 = getelementptr inbounds [3 x double], [3 x double]* %534, i64 0, i64 0
%536 = load double, double* %535
%537 = call double @llvm.fabs.f64(double %536)
store double %537, double* %8
%538 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %7, i64 0, i64 1
%539 = getelementptr inbounds [3 x double], [3 x double]* %538, i64 0, i64 1
%540 = load double, double* %539
%541 = call double @llvm.fabs.f64(double %540)
store double %541, double* %9
%542 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %7, i64 0, i64 2
%543 = getelementptr inbounds [3 x double], [3 x double]* %542, i64 0, i64 2
%544 = load double, double* %543
%545 = call double @llvm.fabs.f64(double %544)
store double %545, double* %10
store i32 0, i32* %11
%546 = load double, double* %9
%547 = load double, double* %8
%548 = fcmp ogt double %546, %547
br i1 %548, label %549, label %551
549: ; preds = %2
%550 = load double, double* %9
store double %550, double* %8
store i32 1, i32* %11
br label %551
551: ; preds = %549, %2
%552 = load double, double* %10
%553 = load double, double* %8
%554 = fcmp ogt double %552, %553
br i1 %554, label %555, label %556
555: ; preds = %551
store i32 2, i32* %11
br label %556
556: ; preds = %555, %551
%557 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%558 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %557, i64 0
%559 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %558, i64 0, i64 0
%560 = getelementptr inbounds [3 x double], [3 x double]* %559, i64 0, i64 0
%561 = load double, double* %560
%562 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%563 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %562, i64 0
%564 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %563, i64 0, i64 2
%565 = getelementptr inbounds [3 x double], [3 x double]* %564, i64 0, i64 0
%566 = load double, double* %565
%567 = fadd double %561, %566
%568 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%569 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %568, i64 0
%570 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %569, i64 0, i64 0
%571 = getelementptr inbounds [3 x double], [3 x double]* %570, i64 0, i64 2
%572 = load double, double* %571
%573 = fadd double %567, %572
%574 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%575 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %574, i64 0
%576 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %575, i64 0, i64 2
%577 = getelementptr inbounds [3 x double], [3 x double]* %576, i64 0, i64 2
%578 = load double, double* %577
%579 = fadd double %573, %578
%580 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%581 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %580, i64 0
%582 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %581, i64 0, i64 0
%583 = getelementptr inbounds [3 x double], [3 x double]* %582, i64 0, i64 1
%584 = load double, double* %583
%585 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%586 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %585, i64 0
%587 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %586, i64 0, i64 2
%588 = getelementptr inbounds [3 x double], [3 x double]* %587, i64 0, i64 1
%589 = load double, double* %588
%590 = fadd double %584, %589
%591 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%592 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %591, i64 0
%593 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %592, i64 0, i64 1
%594 = getelementptr inbounds [3 x double], [3 x double]* %593, i64 0, i64 0
%595 = load double, double* %594
%596 = fadd double %590, %595
%597 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%598 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %597, i64 0
%599 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %598, i64 0, i64 1
%600 = getelementptr inbounds [3 x double], [3 x double]* %599, i64 0, i64 2
%601 = load double, double* %600
%602 = fadd double %596, %601
%603 = call double @llvm.fmuladd.f64(double 2.000000e+00, double %602, double %579)
%604 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%605 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %604, i64 0
%606 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %605, i64 0, i64 1
%607 = getelementptr inbounds [3 x double], [3 x double]* %606, i64 0, i64 1
%608 = load double, double* %607
%609 = call double @llvm.fmuladd.f64(double 4.000000e+00, double %608, double %603)
store double %609, double* %5
%610 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%611 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %610, i64 2
%612 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %611, i64 0, i64 0
%613 = getelementptr inbounds [3 x double], [3 x double]* %612, i64 0, i64 0
%614 = load double, double* %613
%615 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%616 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %615, i64 2
%617 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %616, i64 0, i64 2
%618 = getelementptr inbounds [3 x double], [3 x double]* %617, i64 0, i64 0
%619 = load double, double* %618
%620 = fadd double %614, %619
%621 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%622 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %621, i64 2
%623 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %622, i64 0, i64 0
%624 = getelementptr inbounds [3 x double], [3 x double]* %623, i64 0, i64 2
%625 = load double, double* %624
%626 = fadd double %620, %625
%627 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%628 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %627, i64 2
%629 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %628, i64 0, i64 2
%630 = getelementptr inbounds [3 x double], [3 x double]* %629, i64 0, i64 2
%631 = load double, double* %630
%632 = fadd double %626, %631
%633 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%634 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %633, i64 2
%635 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %634, i64 0, i64 0
%636 = getelementptr inbounds [3 x double], [3 x double]* %635, i64 0, i64 1
%637 = load double, double* %636
%638 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%639 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %638, i64 2
%640 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %639, i64 0, i64 2
%641 = getelementptr inbounds [3 x double], [3 x double]* %640, i64 0, i64 1
%642 = load double, double* %641
%643 = fadd double %637, %642
%644 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%645 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %644, i64 2
%646 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %645, i64 0, i64 1
%647 = getelementptr inbounds [3 x double], [3 x double]* %646, i64 0, i64 0
%648 = load double, double* %647
%649 = fadd double %643, %648
%650 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%651 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %650, i64 2
%652 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %651, i64 0, i64 1
%653 = getelementptr inbounds [3 x double], [3 x double]* %652, i64 0, i64 2
%654 = load double, double* %653
%655 = fadd double %649, %654
%656 = call double @llvm.fmuladd.f64(double 2.000000e+00, double %655, double %632)
%657 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%658 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %657, i64 2
%659 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %658, i64 0, i64 1
%660 = getelementptr inbounds [3 x double], [3 x double]* %659, i64 0, i64 1
%661 = load double, double* %660
%662 = call double @llvm.fmuladd.f64(double 4.000000e+00, double %661, double %656)
store double %662, double* %6
%663 = load double, double* %5
%664 = load double, double* %6
%665 = fsub double %663, %664
%666 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %7, i64 0, i64 3
%667 = getelementptr inbounds [3 x double], [3 x double]* %666, i64 0, i64 0
store double %665, double* %667
%668 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%669 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %668, i64 0
%670 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %669, i64 0, i64 0
%671 = getelementptr inbounds [3 x double], [3 x double]* %670, i64 0, i64 0
%672 = load double, double* %671
%673 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%674 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %673, i64 0
%675 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %674, i64 0, i64 0
%676 = getelementptr inbounds [3 x double], [3 x double]* %675, i64 0, i64 2
%677 = load double, double* %676
%678 = fadd double %672, %677
%679 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%680 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %679, i64 2
%681 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %680, i64 0, i64 0
%682 = getelementptr inbounds [3 x double], [3 x double]* %681, i64 0, i64 0
%683 = load double, double* %682
%684 = fadd double %678, %683
%685 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%686 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %685, i64 2
%687 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %686, i64 0, i64 0
%688 = getelementptr inbounds [3 x double], [3 x double]* %687, i64 0, i64 2
%689 = load double, double* %688
%690 = fadd double %684, %689
%691 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%692 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %691, i64 0
%693 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %692, i64 0, i64 0
%694 = getelementptr inbounds [3 x double], [3 x double]* %693, i64 0, i64 1
%695 = load double, double* %694
%696 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%697 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %696, i64 2
%698 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %697, i64 0, i64 0
%699 = getelementptr inbounds [3 x double], [3 x double]* %698, i64 0, i64 1
%700 = load double, double* %699
%701 = fadd double %695, %700
%702 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%703 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %702, i64 1
%704 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %703, i64 0, i64 0
%705 = getelementptr inbounds [3 x double], [3 x double]* %704, i64 0, i64 0
%706 = load double, double* %705
%707 = fadd double %701, %706
%708 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%709 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %708, i64 1
%710 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %709, i64 0, i64 0
%711 = getelementptr inbounds [3 x double], [3 x double]* %710, i64 0, i64 2
%712 = load double, double* %711
%713 = fadd double %707, %712
%714 = call double @llvm.fmuladd.f64(double 2.000000e+00, double %713, double %690)
%715 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%716 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %715, i64 1
%717 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %716, i64 0, i64 0
%718 = getelementptr inbounds [3 x double], [3 x double]* %717, i64 0, i64 1
%719 = load double, double* %718
%720 = call double @llvm.fmuladd.f64(double 4.000000e+00, double %719, double %714)
store double %720, double* %5
%721 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%722 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %721, i64 0
%723 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %722, i64 0, i64 2
%724 = getelementptr inbounds [3 x double], [3 x double]* %723, i64 0, i64 0
%725 = load double, double* %724
%726 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%727 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %726, i64 0
%728 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %727, i64 0, i64 2
%729 = getelementptr inbounds [3 x double], [3 x double]* %728, i64 0, i64 2
%730 = load double, double* %729
%731 = fadd double %725, %730
%732 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%733 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %732, i64 2
%734 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %733, i64 0, i64 2
%735 = getelementptr inbounds [3 x double], [3 x double]* %734, i64 0, i64 0
%736 = load double, double* %735
%737 = fadd double %731, %736
%738 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%739 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %738, i64 2
%740 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %739, i64 0, i64 2
%741 = getelementptr inbounds [3 x double], [3 x double]* %740, i64 0, i64 2
%742 = load double, double* %741
%743 = fadd double %737, %742
%744 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%745 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %744, i64 0
%746 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %745, i64 0, i64 2
%747 = getelementptr inbounds [3 x double], [3 x double]* %746, i64 0, i64 1
%748 = load double, double* %747
%749 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%750 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %749, i64 2
%751 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %750, i64 0, i64 2
%752 = getelementptr inbounds [3 x double], [3 x double]* %751, i64 0, i64 1
%753 = load double, double* %752
%754 = fadd double %748, %753
%755 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%756 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %755, i64 1
%757 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %756, i64 0, i64 2
%758 = getelementptr inbounds [3 x double], [3 x double]* %757, i64 0, i64 0
%759 = load double, double* %758
%760 = fadd double %754, %759
%761 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%762 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %761, i64 1
%763 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %762, i64 0, i64 2
%764 = getelementptr inbounds [3 x double], [3 x double]* %763, i64 0, i64 2
%765 = load double, double* %764
%766 = fadd double %760, %765
%767 = call double @llvm.fmuladd.f64(double 2.000000e+00, double %766, double %743)
%768 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%769 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %768, i64 1
%770 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %769, i64 0, i64 2
%771 = getelementptr inbounds [3 x double], [3 x double]* %770, i64 0, i64 1
%772 = load double, double* %771
%773 = call double @llvm.fmuladd.f64(double 4.000000e+00, double %772, double %767)
store double %773, double* %6
%774 = load double, double* %5
%775 = load double, double* %6
%776 = fsub double %774, %775
%777 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %7, i64 0, i64 3
%778 = getelementptr inbounds [3 x double], [3 x double]* %777, i64 0, i64 1
store double %776, double* %778
%779 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%780 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %779, i64 0
%781 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %780, i64 0, i64 0
%782 = getelementptr inbounds [3 x double], [3 x double]* %781, i64 0, i64 0
%783 = load double, double* %782
%784 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%785 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %784, i64 0
%786 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %785, i64 0, i64 2
%787 = getelementptr inbounds [3 x double], [3 x double]* %786, i64 0, i64 0
%788 = load double, double* %787
%789 = fadd double %783, %788
%790 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%791 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %790, i64 2
%792 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %791, i64 0, i64 0
%793 = getelementptr inbounds [3 x double], [3 x double]* %792, i64 0, i64 0
%794 = load double, double* %793
%795 = fadd double %789, %794
%796 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%797 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %796, i64 2
%798 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %797, i64 0, i64 2
%799 = getelementptr inbounds [3 x double], [3 x double]* %798, i64 0, i64 0
%800 = load double, double* %799
%801 = fadd double %795, %800
%802 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%803 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %802, i64 0
%804 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %803, i64 0, i64 1
%805 = getelementptr inbounds [3 x double], [3 x double]* %804, i64 0, i64 0
%806 = load double, double* %805
%807 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%808 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %807, i64 2
%809 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %808, i64 0, i64 1
%810 = getelementptr inbounds [3 x double], [3 x double]* %809, i64 0, i64 0
%811 = load double, double* %810
%812 = fadd double %806, %811
%813 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%814 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %813, i64 1
%815 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %814, i64 0, i64 0
%816 = getelementptr inbounds [3 x double], [3 x double]* %815, i64 0, i64 0
%817 = load double, double* %816
%818 = fadd double %812, %817
%819 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%820 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %819, i64 1
%821 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %820, i64 0, i64 2
%822 = getelementptr inbounds [3 x double], [3 x double]* %821, i64 0, i64 0
%823 = load double, double* %822
%824 = fadd double %818, %823
%825 = call double @llvm.fmuladd.f64(double 2.000000e+00, double %824, double %801)
%826 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%827 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %826, i64 1
%828 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %827, i64 0, i64 1
%829 = getelementptr inbounds [3 x double], [3 x double]* %828, i64 0, i64 0
%830 = load double, double* %829
%831 = call double @llvm.fmuladd.f64(double 4.000000e+00, double %830, double %825)
store double %831, double* %5
%832 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%833 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %832, i64 0
%834 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %833, i64 0, i64 0
%835 = getelementptr inbounds [3 x double], [3 x double]* %834, i64 0, i64 2
%836 = load double, double* %835
%837 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%838 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %837, i64 0
%839 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %838, i64 0, i64 2
%840 = getelementptr inbounds [3 x double], [3 x double]* %839, i64 0, i64 2
%841 = load double, double* %840
%842 = fadd double %836, %841
%843 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%844 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %843, i64 2
%845 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %844, i64 0, i64 0
%846 = getelementptr inbounds [3 x double], [3 x double]* %845, i64 0, i64 2
%847 = load double, double* %846
%848 = fadd double %842, %847
%849 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%850 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %849, i64 2
%851 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %850, i64 0, i64 2
%852 = getelementptr inbounds [3 x double], [3 x double]* %851, i64 0, i64 2
%853 = load double, double* %852
%854 = fadd double %848, %853
%855 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%856 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %855, i64 0
%857 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %856, i64 0, i64 1
%858 = getelementptr inbounds [3 x double], [3 x double]* %857, i64 0, i64 2
%859 = load double, double* %858
%860 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%861 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %860, i64 2
%862 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %861, i64 0, i64 1
%863 = getelementptr inbounds [3 x double], [3 x double]* %862, i64 0, i64 2
%864 = load double, double* %863
%865 = fadd double %859, %864
%866 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%867 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %866, i64 1
%868 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %867, i64 0, i64 0
%869 = getelementptr inbounds [3 x double], [3 x double]* %868, i64 0, i64 2
%870 = load double, double* %869
%871 = fadd double %865, %870
%872 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%873 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %872, i64 1
%874 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %873, i64 0, i64 2
%875 = getelementptr inbounds [3 x double], [3 x double]* %874, i64 0, i64 2
%876 = load double, double* %875
%877 = fadd double %871, %876
%878 = call double @llvm.fmuladd.f64(double 2.000000e+00, double %877, double %854)
%879 = load [3 x [3 x double]]*, [3 x [3 x double]]** %3
%880 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %879, i64 1
%881 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %880, i64 0, i64 1
%882 = getelementptr inbounds [3 x double], [3 x double]* %881, i64 0, i64 2
%883 = load double, double* %882
%884 = call double @llvm.fmuladd.f64(double 4.000000e+00, double %883, double %878)
store double %884, double* %6
%885 = load double, double* %5
%886 = load double, double* %6
%887 = fsub double %885, %886
%888 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %7, i64 0, i64 3
%889 = getelementptr inbounds [3 x double], [3 x double]* %888, i64 0, i64 2
store double %887, double* %889
%890 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %7, i64 0, i64 3
%891 = getelementptr inbounds [3 x double], [3 x double]* %890, i64 0, i64 0
%892 = load double, double* %891
%893 = call double @llvm.fabs.f64(double %892)
%894 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %7, i64 0, i64 3
%895 = getelementptr inbounds [3 x double], [3 x double]* %894, i64 0, i64 1
%896 = load double, double* %895
%897 = call double @llvm.fabs.f64(double %896)
%898 = fadd double %893, %897
%899 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %7, i64 0, i64 3
%900 = getelementptr inbounds [3 x double], [3 x double]* %899, i64 0, i64 2
%901 = load double, double* %900
%902 = call double @llvm.fabs.f64(double %901)
%903 = fadd double %898, %902
%904 = fadd double %903, 1.000000e-30
store double %904, double* %8
%905 = load double, double* %8
%906 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %7, i64 0, i64 3
%907 = getelementptr inbounds [3 x double], [3 x double]* %906, i64 0, i64 0
%908 = load double, double* %907
%909 = fdiv double %908, %905
store double %909, double* %907
%910 = load double, double* %8
%911 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %7, i64 0, i64 3
%912 = getelementptr inbounds [3 x double], [3 x double]* %911, i64 0, i64 1
%913 = load double, double* %912
%914 = fdiv double %913, %910
store double %914, double* %912
%915 = load double, double* %8
%916 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %7, i64 0, i64 3
%917 = getelementptr inbounds [3 x double], [3 x double]* %916, i64 0, i64 2
%918 = load double, double* %917
%919 = fdiv double %918, %915
store double %919, double* %917
%920 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %7, i64 0, i64 3
%921 = getelementptr inbounds [3 x double], [3 x double]* %920, i64 0, i64 0
%922 = load double, double* %921
%923 = call double @llvm.fabs.f64(double %922)
store double %923, double* %8
%924 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %7, i64 0, i64 3
%925 = getelementptr inbounds [3 x double], [3 x double]* %924, i64 0, i64 1
%926 = load double, double* %925
%927 = call double @llvm.fabs.f64(double %926)
store double %927, double* %9
%928 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %7, i64 0, i64 3
%929 = getelementptr inbounds [3 x double], [3 x double]* %928, i64 0, i64 2
%930 = load double, double* %929
%931 = call double @llvm.fabs.f64(double %930)
store double %931, double* %10
%932 = load double, double* %9
%933 = load double, double* %8
%934 = fcmp ogt double %932, %933
br i1 %934, label %935, label %937
935: ; preds = %556
%936 = load double, double* %9
store double %936, double* %8
br label %937
937: ; preds = %935, %556
%938 = load double, double* %10
%939 = load double, double* %8
%940 = fcmp ogt double %938, %939
br i1 %940, label %941, label %943
941: ; preds = %937
%942 = load double, double* %10
store double %942, double* %8
br label %943
943: ; preds = %941, %937
%944 = load i32, i32* %11
%945 = sext i32 %944 to i64
%946 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %7, i64 0, i64 %945
%947 = load i32, i32* %11
%948 = sext i32 %947 to i64
%949 = getelementptr inbounds [3 x double], [3 x double]* %946, i64 0, i64 %948
%950 = load double, double* %949
%951 = call double @llvm.fabs.f64(double %950)
%952 = load double, double* %8
%953 = fcmp ogt double %951, %952
br i1 %953, label %954, label %955
954: ; preds = %943
store i32 3, i32* %11
br label %955
955: ; preds = %954, %943
%956 = load i32, i32* %11
%957 = sext i32 %956 to i64
%958 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %7, i64 0, i64 %957
%959 = getelementptr inbounds [3 x double], [3 x double]* %958, i64 0, i64 0
%960 = load double, double* %959
%961 = load double*, double** %4
%962 = getelementptr inbounds double, double* %961, i64 0
store double %960, double* %962
%963 = load i32, i32* %11
%964 = sext i32 %963 to i64
%965 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %7, i64 0, i64 %964
%966 = getelementptr inbounds [3 x double], [3 x double]* %965, i64 0, i64 1
%967 = load double, double* %966
%968 = load double*, double** %4
%969 = getelementptr inbounds double, double* %968, i64 1
store double %967, double* %969
%970 = load i32, i32* %11
%971 = sext i32 %970 to i64
%972 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %7, i64 0, i64 %971
%973 = getelementptr inbounds [3 x double], [3 x double]* %972, i64 0, i64 2
%974 = load double, double* %973
%975 = load double*, double** %4
%976 = getelementptr inbounds double, double* %975, i64 2
store double %974, double* %976
ret void
}

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