int fast_eigen3x3(double A[3][3], double V[3][3], double d[3]) {
  const double smallv = 1e-12;
  double c0, c1, c2;
  int check;
  double l1, l2, l3;
  double t;
  double a1, a2, a3, b1, b2;
  double da[3];
  check = (((A[0][1]) > (-A[0][1]) ? (A[0][1]) : (-A[0][1])) < smallv) +
          (((A[0][2]) > (-A[0][2]) ? (A[0][2]) : (-A[0][2])) < smallv) +
          (((A[1][2]) > (-A[1][2]) ? (A[1][2]) : (-A[1][2])) < smallv);
  if (check > 1) {
    return 0;
  }
  c0 = -(A[0][0] * A[1][1] * A[2][2] + 2 * A[0][1] * A[0][2] * A[1][2] -
         A[0][0] * (A[1][2] * A[1][2]) - A[1][1] * (A[0][2] * A[0][2]) -
         A[2][2] * (A[0][1] * A[0][1]));
  c1 = A[0][0] * A[1][1] - (A[0][1] * A[0][1]) + A[0][0] * A[2][2] -
       (A[0][2] * A[0][2]) + A[1][1] * A[2][2] - (A[1][2] * A[1][2]);
  c2 = -(A[0][0] + A[1][1] + A[2][2]);
  roots3(d, c0, c1, c2);
  da[0] = ((d[0]) > (-d[0]) ? (d[0]) : (-d[0]));
  da[1] = ((d[1]) > (-d[1]) ? (d[1]) : (-d[1]));
  da[2] = ((d[2]) > (-d[2]) ? (d[2]) : (-d[2]));
  if (da[0] >= da[1]) {
    if (da[0] > da[2]) {
      t = d[0];
      d[0] = d[2];
      d[2] = t;
      t = da[0];
      da[0] = da[2];
      da[2] = t;
    }
  } else if (da[1] > da[2]) {
    t = d[1];
    d[1] = d[2];
    d[2] = t;
    t = da[1];
    da[1] = da[2];
    da[2] = t;
  }
  if (da[0] >= da[1]) {
    t = d[0];
    d[0] = d[1];
    d[1] = t;
    t = da[0];
    da[0] = da[1];
    da[1] = t;
  }
  if ((da[1] - da[0]) < smallv) {
    return 0;
  }
  if ((da[2] - da[1]) < smallv) {
    return 0;
  }
  a1 = A[0][1] * A[1][2];
  a2 = A[0][1] * A[0][2];
  a3 = (A[0][1] * A[0][1]);
  b1 = A[0][0] - d[0];
  b2 = A[1][1] - d[0];
  V[0][0] = a1 - A[0][2] * b2;
  V[1][0] = a2 - A[1][2] * b1;
  V[2][0] = b1 * b2 - a3;
  b1 = A[0][0] - d[1];
  b2 = A[1][1] - d[1];
  V[0][1] = a1 - A[0][2] * b2;
  V[1][1] = a2 - A[1][2] * b1;
  V[2][1] = b1 * b2 - a3;
  b1 = A[0][0] - d[2];
  b2 = A[1][1] - d[2];
  V[0][2] = a1 - A[0][2] * b2;
  V[1][2] = a2 - A[1][2] * b1;
  V[2][2] = b1 * b2 - a3;
  l1 = sqrt((V[0][0] * V[0][0]) + (V[1][0] * V[1][0]) + (V[2][0] * V[2][0]));
  l2 = sqrt((V[0][1] * V[0][1]) + (V[1][1] * V[1][1]) + (V[2][1] * V[2][1]));
  l3 = sqrt((V[0][2] * V[0][2]) + (V[1][2] * V[1][2]) + (V[2][2] * V[2][2]));
  if (l1 < smallv) {
    return 0;
  }
  if (l2 < smallv) {
    return 0;
  }
  if (l3 < smallv) {
    return 0;
  }
  V[0][0] /= l1;
  V[0][1] /= l2;
  V[0][2] /= l3;
  V[1][0] /= l1;
  V[1][1] /= l2;
  V[1][2] /= l3;
  V[2][0] /= l1;
  V[2][1] /= l2;
  V[2][2] /= l3;
  return 1;
}


x86 assembly (clang, -O0):
<fast_eigen3x3>:
push   %rbp
mov    %rsp,%rbp
sub    $0xf0,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
movsd  0xec1(%rip),%xmm0
movsd  %xmm0,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
ucomisd %xmm1,%xmm0
jbe    118d <fast_eigen3x3+0x6d>
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
jmp    11b5 <fast_eigen3x3+0x95>
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0xb8(%rbp),%xmm1
ff
movsd  0xe3b(%rip),%xmm0
ucomisd %xmm1,%xmm0
seta   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0xbc(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
ucomisd %xmm1,%xmm0
jbe    1220 <fast_eigen3x3+0x100>
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
jmp    1248 <fast_eigen3x3+0x128>
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0xbc(%rbp),%eax
movsd  -0xc8(%rbp),%xmm1
ff
movsd  0xda2(%rip),%xmm0
ucomisd %xmm1,%xmm0
seta   %cl
and    $0x1,%cl
movzbl %cl,%ecx
add    %ecx,%eax
mov    %eax,-0xcc(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
ucomisd %xmm1,%xmm0
jbe    12bc <fast_eigen3x3+0x19c>
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
jmp    12e4 <fast_eigen3x3+0x1c4>
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0xcc(%rbp),%eax
movsd  -0xd8(%rbp),%xmm1
ff
movsd  0xd06(%rip),%xmm0
ucomisd %xmm1,%xmm0
seta   %cl
and    $0x1,%cl
movzbl %cl,%ecx
add    %ecx,%eax
mov    %eax,-0x44(%rbp)
cmpl   $0x1,-0x44(%rbp)
jle    1322 <fast_eigen3x3+0x202>
movl   $0x0,-0x4(%rbp)
jmp    1dc2 <fast_eigen3x3+0xca2>
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x20(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x40(%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0xcc0(%rip),%xmm0
mulsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x28(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm2
mov    -0x10(%rbp),%rax
mulsd  0x28(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
mov    -0x10(%rbp),%rax
mulsd  0x10(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x40(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm2
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x40(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x40(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
addsd  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
addsd  0x40(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x20(%rbp),%rdi
movsd  -0x30(%rbp),%xmm0
movsd  -0x38(%rbp),%xmm1
movsd  -0x40(%rbp),%xmm2
mov    $0x3,%al
call   1030 <roots3@plt>
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
ucomisd %xmm1,%xmm0
jbe    15a2 <fast_eigen3x3+0x482>
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
jmp    15c9 <fast_eigen3x3+0x4a9>
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  0x8(%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
ucomisd %xmm1,%xmm0
jbe    1622 <fast_eigen3x3+0x502>
mov    -0x20(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
jmp    164a <fast_eigen3x3+0x52a>
mov    -0x20(%rbp),%rax
movsd  0x8(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  0x10(%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
ucomisd %xmm1,%xmm0
jbe    16a3 <fast_eigen3x3+0x583>
mov    -0x20(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
jmp    16cb <fast_eigen3x3+0x5ab>
mov    -0x20(%rbp),%rax
movsd  0x10(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  -0xf0(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
ucomisd -0xa8(%rbp),%xmm0
ff
jb     1762 <fast_eigen3x3+0x642>
movsd  -0xb0(%rbp),%xmm0
ff
ucomisd -0xa0(%rbp),%xmm0
jbe    175d <fast_eigen3x3+0x63d>
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x20(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x68(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0x68(%rbp)
movsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
jmp    17d5 <fast_eigen3x3+0x6b5>
movsd  -0xa8(%rbp),%xmm0
ff
ucomisd -0xa0(%rbp),%xmm0
ff
jbe    17d0 <fast_eigen3x3+0x6b0>
mov    -0x20(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x20(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0x68(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x68(%rbp)
movsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
jmp    17d5 <fast_eigen3x3+0x6b5>
movsd  -0xb0(%rbp),%xmm0
ff
ucomisd -0xa8(%rbp),%xmm0
ff
jb     1841 <fast_eigen3x3+0x721>
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x20(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x68(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0x68(%rbp)
movsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xa8(%rbp),%xmm1
ff
subsd  -0xb0(%rbp),%xmm1
ff
movsd  0x7a7(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    186f <fast_eigen3x3+0x74f>
movl   $0x0,-0x4(%rbp)
jmp    1dc2 <fast_eigen3x3+0xca2>
movsd  -0xa0(%rbp),%xmm1
ff
subsd  -0xa8(%rbp),%xmm1
ff
movsd  0x779(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    189d <fast_eigen3x3+0x77d>
movl   $0x0,-0x4(%rbp)
jmp    1dc2 <fast_eigen3x3+0xca2>
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x28(%rax),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x20(%rbp),%rax
subsd  (%rax),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x20(%rbp),%rax
subsd  (%rax),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x70(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  -0x90(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x78(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm0
movsd  -0x88(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x18(%rax)
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x90(%rbp),%xmm2
ff
movsd  -0x80(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x30(%rax)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x20(%rbp),%rax
subsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x20(%rbp),%rax
subsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x70(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  -0x90(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0x78(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm0
movsd  -0x88(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x20(%rax)
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x90(%rbp),%xmm2
ff
movsd  -0x80(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x38(%rax)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x20(%rbp),%rax
subsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x20(%rbp),%rax
subsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x70(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  -0x90(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movsd  -0x78(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm0
movsd  -0x88(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x28(%rax)
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x90(%rbp),%xmm2
ff
movsd  -0x80(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x40(%rax)
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x18(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x18(%rbp),%rax
mulsd  0x18(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
movsd  0x30(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x30(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1040 <sqrt@plt>
movsd  %xmm0,-0x50(%rbp)
mov    -0x18(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x18(%rbp),%rax
movsd  0x8(%rax),%xmm2
mov    -0x18(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x18(%rbp),%rax
mulsd  0x20(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
movsd  0x38(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x38(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1040 <sqrt@plt>
movsd  %xmm0,-0x58(%rbp)
mov    -0x18(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x18(%rbp),%rax
movsd  0x10(%rax),%xmm2
mov    -0x18(%rbp),%rax
movsd  0x28(%rax),%xmm0
mov    -0x18(%rbp),%rax
mulsd  0x28(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
movsd  0x40(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x40(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1040 <sqrt@plt>
movsd  %xmm0,-0x60(%rbp)
movsd  0x367(%rip),%xmm0
ucomisd -0x50(%rbp),%xmm0
jbe    1cb0 <fast_eigen3x3+0xb90>
movl   $0x0,-0x4(%rbp)
jmp    1dc2 <fast_eigen3x3+0xca2>
movsd  0x348(%rip),%xmm0
ucomisd -0x58(%rbp),%xmm0
jbe    1ccf <fast_eigen3x3+0xbaf>
movl   $0x0,-0x4(%rbp)
jmp    1dc2 <fast_eigen3x3+0xca2>
movsd  0x329(%rip),%xmm0
ucomisd -0x60(%rbp),%xmm0
jbe    1cee <fast_eigen3x3+0xbce>
movl   $0x0,-0x4(%rbp)
jmp    1dc2 <fast_eigen3x3+0xca2>
movsd  -0x50(%rbp),%xmm1
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
movsd  -0x58(%rbp),%xmm1
mov    -0x18(%rbp),%rax
movsd  0x8(%rax),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rax)
movsd  -0x60(%rbp),%xmm1
mov    -0x18(%rbp),%rax
movsd  0x10(%rax),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x10(%rax)
movsd  -0x50(%rbp),%xmm1
mov    -0x18(%rbp),%rax
movsd  0x18(%rax),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x18(%rax)
movsd  -0x58(%rbp),%xmm1
mov    -0x18(%rbp),%rax
movsd  0x20(%rax),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x20(%rax)
movsd  -0x60(%rbp),%xmm1
mov    -0x18(%rbp),%rax
movsd  0x28(%rax),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x28(%rax)
movsd  -0x50(%rbp),%xmm1
mov    -0x18(%rbp),%rax
movsd  0x30(%rax),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x30(%rax)
movsd  -0x58(%rbp),%xmm1
mov    -0x18(%rbp),%rax
movsd  0x38(%rax),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x38(%rax)
movsd  -0x60(%rbp),%xmm1
mov    -0x18(%rbp),%rax
movsd  0x40(%rax),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x40(%rax)
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0xf0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<fast_eigen3x3>:
push   %rbp
push   %r15
push   %r14
push   %rbx
sub    $0x28,%rsp
movsd  0x8(%rdi),%xmm5
movapd 0xec8(%rip),%xmm11
movapd %xmm5,%xmm0
xorpd  %xmm11,%xmm0
movapd %xmm5,%xmm1
maxsd  %xmm0,%xmm1
movsd  0xebf(%rip),%xmm2
xor    %eax,%eax
ucomisd %xmm1,%xmm2
movsd  0x10(%rdi),%xmm6
seta   %al
movapd %xmm6,%xmm4
xorpd  %xmm11,%xmm4
movapd %xmm6,%xmm0
maxsd  %xmm4,%xmm0
xor    %ecx,%ecx
ucomisd %xmm0,%xmm2
seta   %cl
add    %eax,%ecx
movsd  0x28(%rdi),%xmm10
movapd %xmm10,%xmm1
xorpd  %xmm11,%xmm1
movapd %xmm10,%xmm0
maxsd  %xmm1,%xmm0
xor    %eax,%eax
ucomisd %xmm0,%xmm2
seta   %al
add    %ecx,%eax
xor    %r14d,%r14d
cmp    $0x1,%eax
ja     159b <fast_eigen3x3+0x47b>
mov    %rdi,%rbp
mov    %rdx,%rbx
mov    %rsi,%r15
movsd  (%rdi),%xmm2
movsd  0x20(%rdi),%xmm7
movapd %xmm2,%xmm8
mulsd  %xmm7,%xmm8
movsd  0x40(%rdi),%xmm9
movapd %xmm5,%xmm3
addsd  %xmm5,%xmm3
mulsd  %xmm6,%xmm3
mulsd  %xmm10,%xmm3
movapd %xmm8,%xmm0
mulsd  %xmm9,%xmm0
addsd  %xmm3,%xmm0
movapd %xmm10,%xmm3
mulsd  %xmm10,%xmm3
mulsd  %xmm2,%xmm3
subsd  %xmm3,%xmm0
mulsd  %xmm6,%xmm4
mulsd  %xmm6,%xmm6
mulsd  %xmm7,%xmm6
subsd  %xmm6,%xmm0
mulsd  %xmm5,%xmm5
movapd %xmm2,%xmm3
mulsd  %xmm9,%xmm3
addsd  %xmm7,%xmm2
mulsd  %xmm9,%xmm7
addsd  %xmm9,%xmm2
mulsd  %xmm5,%xmm9
subsd  %xmm9,%xmm0
xorpd  %xmm11,%xmm0
subsd  %xmm5,%xmm8
addsd  %xmm8,%xmm3
addsd  %xmm4,%xmm3
addsd  %xmm3,%xmm7
mulsd  %xmm10,%xmm1
addsd  %xmm7,%xmm1
xorpd  %xmm11,%xmm2
mov    %rdx,%rdi
mov    $0x3,%al
call   1030 <roots3@plt>
movsd  (%rbx),%xmm4
movsd  0x8(%rbx),%xmm1
movapd %xmm4,%xmm0
movapd 0xd89(%rip),%xmm6
xorpd  %xmm6,%xmm0
movapd %xmm4,%xmm2
maxsd  %xmm0,%xmm2
movapd %xmm1,%xmm3
xorpd  %xmm6,%xmm3
movapd %xmm1,%xmm0
maxsd  %xmm3,%xmm0
movsd  0x10(%rbx),%xmm5
xorpd  %xmm5,%xmm6
movapd %xmm5,%xmm3
maxsd  %xmm6,%xmm3
ucomisd %xmm0,%xmm2
jae    12cf <fast_eigen3x3+0x1af>
ucomisd %xmm3,%xmm0
jbe    12fb <fast_eigen3x3+0x1db>
lea    0x8(%rbx),%rax
movapd %xmm1,%xmm8
movapd %xmm5,%xmm1
movapd %xmm4,%xmm7
movapd %xmm0,%xmm6
movapd %xmm3,%xmm0
movapd %xmm2,%xmm3
jmp    12e5 <fast_eigen3x3+0x1c5>
ucomisd %xmm3,%xmm2
mov    %rbx,%rax
movapd %xmm4,%xmm8
movapd %xmm5,%xmm7
movapd %xmm2,%xmm6
jbe    12fb <fast_eigen3x3+0x1db>
movapd %xmm3,%xmm2
movsd  %xmm5,(%rax)
movsd  %xmm8,0x10(%rbx)
movapd %xmm7,%xmm4
movapd %xmm6,%xmm3
ucomisd %xmm0,%xmm2
jae    130f <fast_eigen3x3+0x1ef>
movapd %xmm4,%xmm1
movapd %xmm0,%xmm4
movapd %xmm2,%xmm0
jmp    131c <fast_eigen3x3+0x1fc>
movsd  %xmm1,(%rbx)
movsd  %xmm4,0x8(%rbx)
movapd %xmm2,%xmm4
movapd %xmm4,%xmm2
subsd  %xmm0,%xmm2
movsd  0xce4(%rip),%xmm0
ucomisd %xmm2,%xmm0
ja     159b <fast_eigen3x3+0x47b>
subsd  %xmm4,%xmm3
ucomisd %xmm3,%xmm0
ja     159b <fast_eigen3x3+0x47b>
movsd  0x0(%rbp),%xmm6
movsd  0x8(%rbp),%xmm5
movsd  0x28(%rbp),%xmm8
mulsd  %xmm5,%xmm8
movsd  0x10(%rbp),%xmm4
movapd 0xc9a(%rip),%xmm3
xorpd  %xmm5,%xmm3
mulsd  %xmm5,%xmm3
mulsd  %xmm4,%xmm5
subsd  %xmm1,%xmm6
movsd  0x20(%rbp),%xmm0
subsd  %xmm1,%xmm0
mulsd  %xmm0,%xmm4
movapd %xmm8,%xmm1
subsd  %xmm4,%xmm1
movsd  %xmm1,(%r15)
movsd  0x28(%rbp),%xmm7
mulsd  %xmm6,%xmm7
movapd %xmm5,%xmm9
subsd  %xmm7,%xmm9
movsd  %xmm9,0x18(%r15)
mulsd  %xmm6,%xmm0
addsd  %xmm3,%xmm0
movsd  %xmm0,0x30(%r15)
movsd  0x8(%rbx),%xmm6
movsd  0x0(%rbp),%xmm7
movsd  0x20(%rbp),%xmm2
subsd  %xmm6,%xmm7
subsd  %xmm6,%xmm2
movsd  0x10(%rbp),%xmm6
mulsd  %xmm2,%xmm6
movapd %xmm8,%xmm4
subsd  %xmm6,%xmm4
movsd  %xmm4,0x8(%r15)
movsd  0x28(%rbp),%xmm4
mulsd  %xmm7,%xmm4
movapd %xmm5,%xmm6
subsd  %xmm4,%xmm6
movsd  %xmm6,0x20(%r15)
mulsd  %xmm7,%xmm2
addsd  %xmm3,%xmm2
movsd  %xmm2,0x38(%r15)
movsd  0x10(%rbx),%xmm2
movsd  0x0(%rbp),%xmm4
movsd  0x20(%rbp),%xmm6
subsd  %xmm2,%xmm4
subsd  %xmm2,%xmm6
movsd  0x10(%rbp),%xmm2
mulsd  %xmm6,%xmm2
subsd  %xmm2,%xmm8
movsd  %xmm8,0x10(%r15)
movsd  0x28(%rbp),%xmm2
mulsd  %xmm4,%xmm2
subsd  %xmm2,%xmm5
movsd  %xmm5,0x28(%r15)
mulsd  %xmm4,%xmm6
addsd  %xmm3,%xmm6
movsd  %xmm6,0x40(%r15)
mulsd  %xmm9,%xmm9
mulsd  %xmm1,%xmm1
addsd  %xmm9,%xmm1
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
xorpd  %xmm3,%xmm3
ucomisd %xmm3,%xmm0
jb     1481 <fast_eigen3x3+0x361>
xorps  %xmm2,%xmm2
sqrtsd %xmm0,%xmm2
jmp    148e <fast_eigen3x3+0x36e>
call   1040 <sqrt@plt>
xorpd  %xmm3,%xmm3
movapd %xmm0,%xmm2
movsd  0x8(%r15),%xmm1
movsd  0x20(%r15),%xmm0
mulsd  %xmm0,%xmm0
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  0x38(%r15),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
ucomisd %xmm3,%xmm0
movapd %xmm2,(%rsp)
jb     14c8 <fast_eigen3x3+0x3a8>
xorps  %xmm7,%xmm7
sqrtsd %xmm0,%xmm7
jmp    14d1 <fast_eigen3x3+0x3b1>
call   1040 <sqrt@plt>
movapd %xmm0,%xmm7
movsd  0x10(%r15),%xmm1
movsd  0x28(%r15),%xmm0
mulsd  %xmm0,%xmm0
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  0x40(%r15),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1507 <fast_eigen3x3+0x3e7>
sqrtsd %xmm0,%xmm0
jmp    1518 <fast_eigen3x3+0x3f8>
movapd %xmm7,0x10(%rsp)
call   1040 <sqrt@plt>
movapd 0x10(%rsp),%xmm7
movsd  0xaf0(%rip),%xmm1
movapd (%rsp),%xmm6
ucomisd %xmm6,%xmm1
ja     159b <fast_eigen3x3+0x47b>
ucomisd %xmm7,%xmm1
ja     159b <fast_eigen3x3+0x47b>
ucomisd %xmm0,%xmm1
ja     159b <fast_eigen3x3+0x47b>
movapd %xmm0,%xmm1
unpcklpd %xmm6,%xmm1
unpcklpd %xmm7,%xmm6
movupd (%r15),%xmm2
movupd 0x10(%r15),%xmm3
movupd 0x20(%r15),%xmm4
movupd 0x30(%r15),%xmm5
divpd  %xmm6,%xmm2
movupd %xmm2,(%r15)
divpd  %xmm1,%xmm3
movupd %xmm3,0x10(%r15)
unpcklpd %xmm0,%xmm7
divpd  %xmm7,%xmm4
movupd %xmm4,0x20(%r15)
divpd  %xmm6,%xmm5
movupd %xmm5,0x30(%r15)
movsd  0x40(%r15),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x40(%r15)
mov    $0x1,%r14d
mov    %r14d,%eax
add    $0x28,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @fast_eigen3x3([3 x double]* %0, [3 x double]* %1, double* %2) {
%4 = alloca i32
%5 = alloca [3 x double]*
%6 = alloca [3 x double]*
%7 = alloca double*
%8 = alloca double
%9 = alloca double
%10 = alloca double
%11 = alloca double
%12 = alloca i32
%13 = alloca double
%14 = alloca double
%15 = alloca double
%16 = alloca double
%17 = alloca double
%18 = alloca double
%19 = alloca double
%20 = alloca double
%21 = alloca double
%22 = alloca [3 x double]
store [3 x double]* %0, [3 x double]** %5
store [3 x double]* %1, [3 x double]** %6
store double* %2, double** %7
store double 0x3D719799812DEA11, double* %8
%23 = load [3 x double]*, [3 x double]** %5
%24 = getelementptr inbounds [3 x double], [3 x double]* %23, i64 0
%25 = getelementptr inbounds [3 x double], [3 x double]* %24, i64 0, i64 1
%26 = load double, double* %25
%27 = load [3 x double]*, [3 x double]** %5
%28 = getelementptr inbounds [3 x double], [3 x double]* %27, i64 0
%29 = getelementptr inbounds [3 x double], [3 x double]* %28, i64 0, i64 1
%30 = load double, double* %29
%31 = fneg double %30
%32 = fcmp ogt double %26, %31
br i1 %32, label %33, label %38
33: ; preds = %3
%34 = load [3 x double]*, [3 x double]** %5
%35 = getelementptr inbounds [3 x double], [3 x double]* %34, i64 0
%36 = getelementptr inbounds [3 x double], [3 x double]* %35, i64 0, i64 1
%37 = load double, double* %36
br label %44
38: ; preds = %3
%39 = load [3 x double]*, [3 x double]** %5
%40 = getelementptr inbounds [3 x double], [3 x double]* %39, i64 0
%41 = getelementptr inbounds [3 x double], [3 x double]* %40, i64 0, i64 1
%42 = load double, double* %41
%43 = fneg double %42
br label %44
44: ; preds = %38, %33
%45 = phi double [ %37, %33 ], [ %43, %38 ]
%46 = fcmp olt double %45, 0x3D719799812DEA11
%47 = zext i1 %46 to i32
%48 = load [3 x double]*, [3 x double]** %5
%49 = getelementptr inbounds [3 x double], [3 x double]* %48, i64 0
%50 = getelementptr inbounds [3 x double], [3 x double]* %49, i64 0, i64 2
%51 = load double, double* %50
%52 = load [3 x double]*, [3 x double]** %5
%53 = getelementptr inbounds [3 x double], [3 x double]* %52, i64 0
%54 = getelementptr inbounds [3 x double], [3 x double]* %53, i64 0, i64 2
%55 = load double, double* %54
%56 = fneg double %55
%57 = fcmp ogt double %51, %56
br i1 %57, label %58, label %63
58: ; preds = %44
%59 = load [3 x double]*, [3 x double]** %5
%60 = getelementptr inbounds [3 x double], [3 x double]* %59, i64 0
%61 = getelementptr inbounds [3 x double], [3 x double]* %60, i64 0, i64 2
%62 = load double, double* %61
br label %69
63: ; preds = %44
%64 = load [3 x double]*, [3 x double]** %5
%65 = getelementptr inbounds [3 x double], [3 x double]* %64, i64 0
%66 = getelementptr inbounds [3 x double], [3 x double]* %65, i64 0, i64 2
%67 = load double, double* %66
%68 = fneg double %67
br label %69
69: ; preds = %63, %58
%70 = phi double [ %62, %58 ], [ %68, %63 ]
%71 = fcmp olt double %70, 0x3D719799812DEA11
%72 = zext i1 %71 to i32
%73 = add nsw i32 %47, %72
%74 = load [3 x double]*, [3 x double]** %5
%75 = getelementptr inbounds [3 x double], [3 x double]* %74, i64 1
%76 = getelementptr inbounds [3 x double], [3 x double]* %75, i64 0, i64 2
%77 = load double, double* %76
%78 = load [3 x double]*, [3 x double]** %5
%79 = getelementptr inbounds [3 x double], [3 x double]* %78, i64 1
%80 = getelementptr inbounds [3 x double], [3 x double]* %79, i64 0, i64 2
%81 = load double, double* %80
%82 = fneg double %81
%83 = fcmp ogt double %77, %82
br i1 %83, label %84, label %89
84: ; preds = %69
%85 = load [3 x double]*, [3 x double]** %5
%86 = getelementptr inbounds [3 x double], [3 x double]* %85, i64 1
%87 = getelementptr inbounds [3 x double], [3 x double]* %86, i64 0, i64 2
%88 = load double, double* %87
br label %95
89: ; preds = %69
%90 = load [3 x double]*, [3 x double]** %5
%91 = getelementptr inbounds [3 x double], [3 x double]* %90, i64 1
%92 = getelementptr inbounds [3 x double], [3 x double]* %91, i64 0, i64 2
%93 = load double, double* %92
%94 = fneg double %93
br label %95
95: ; preds = %89, %84
%96 = phi double [ %88, %84 ], [ %94, %89 ]
%97 = fcmp olt double %96, 0x3D719799812DEA11
%98 = zext i1 %97 to i32
%99 = add nsw i32 %73, %98
store i32 %99, i32* %12
%100 = load i32, i32* %12
%101 = icmp sgt i32 %100, 1
br i1 %101, label %102, label %103
102: ; preds = %95
store i32 0, i32* %4
br label %730
103: ; preds = %95
%104 = load [3 x double]*, [3 x double]** %5
%105 = getelementptr inbounds [3 x double], [3 x double]* %104, i64 0
%106 = getelementptr inbounds [3 x double], [3 x double]* %105, i64 0, i64 0
%107 = load double, double* %106
%108 = load [3 x double]*, [3 x double]** %5
%109 = getelementptr inbounds [3 x double], [3 x double]* %108, i64 1
%110 = getelementptr inbounds [3 x double], [3 x double]* %109, i64 0, i64 1
%111 = load double, double* %110
%112 = fmul double %107, %111
%113 = load [3 x double]*, [3 x double]** %5
%114 = getelementptr inbounds [3 x double], [3 x double]* %113, i64 2
%115 = getelementptr inbounds [3 x double], [3 x double]* %114, i64 0, i64 2
%116 = load double, double* %115
%117 = load [3 x double]*, [3 x double]** %5
%118 = getelementptr inbounds [3 x double], [3 x double]* %117, i64 0
%119 = getelementptr inbounds [3 x double], [3 x double]* %118, i64 0, i64 1
%120 = load double, double* %119
%121 = fmul double 2.000000e+00, %120
%122 = load [3 x double]*, [3 x double]** %5
%123 = getelementptr inbounds [3 x double], [3 x double]* %122, i64 0
%124 = getelementptr inbounds [3 x double], [3 x double]* %123, i64 0, i64 2
%125 = load double, double* %124
%126 = fmul double %121, %125
%127 = load [3 x double]*, [3 x double]** %5
%128 = getelementptr inbounds [3 x double], [3 x double]* %127, i64 1
%129 = getelementptr inbounds [3 x double], [3 x double]* %128, i64 0, i64 2
%130 = load double, double* %129
%131 = fmul double %126, %130
%132 = call double @llvm.fmuladd.f64(double %112, double %116, double %131)
%133 = load [3 x double]*, [3 x double]** %5
%134 = getelementptr inbounds [3 x double], [3 x double]* %133, i64 0
%135 = getelementptr inbounds [3 x double], [3 x double]* %134, i64 0, i64 0
%136 = load double, double* %135
%137 = load [3 x double]*, [3 x double]** %5
%138 = getelementptr inbounds [3 x double], [3 x double]* %137, i64 1
%139 = getelementptr inbounds [3 x double], [3 x double]* %138, i64 0, i64 2
%140 = load double, double* %139
%141 = load [3 x double]*, [3 x double]** %5
%142 = getelementptr inbounds [3 x double], [3 x double]* %141, i64 1
%143 = getelementptr inbounds [3 x double], [3 x double]* %142, i64 0, i64 2
%144 = load double, double* %143
%145 = fmul double %140, %144
%146 = fneg double %136
%147 = call double @llvm.fmuladd.f64(double %146, double %145, double %132)
%148 = load [3 x double]*, [3 x double]** %5
%149 = getelementptr inbounds [3 x double], [3 x double]* %148, i64 1
%150 = getelementptr inbounds [3 x double], [3 x double]* %149, i64 0, i64 1
%151 = load double, double* %150
%152 = load [3 x double]*, [3 x double]** %5
%153 = getelementptr inbounds [3 x double], [3 x double]* %152, i64 0
%154 = getelementptr inbounds [3 x double], [3 x double]* %153, i64 0, i64 2
%155 = load double, double* %154
%156 = load [3 x double]*, [3 x double]** %5
%157 = getelementptr inbounds [3 x double], [3 x double]* %156, i64 0
%158 = getelementptr inbounds [3 x double], [3 x double]* %157, i64 0, i64 2
%159 = load double, double* %158
%160 = fmul double %155, %159
%161 = fneg double %151
%162 = call double @llvm.fmuladd.f64(double %161, double %160, double %147)
%163 = load [3 x double]*, [3 x double]** %5
%164 = getelementptr inbounds [3 x double], [3 x double]* %163, i64 2
%165 = getelementptr inbounds [3 x double], [3 x double]* %164, i64 0, i64 2
%166 = load double, double* %165
%167 = load [3 x double]*, [3 x double]** %5
%168 = getelementptr inbounds [3 x double], [3 x double]* %167, i64 0
%169 = getelementptr inbounds [3 x double], [3 x double]* %168, i64 0, i64 1
%170 = load double, double* %169
%171 = load [3 x double]*, [3 x double]** %5
%172 = getelementptr inbounds [3 x double], [3 x double]* %171, i64 0
%173 = getelementptr inbounds [3 x double], [3 x double]* %172, i64 0, i64 1
%174 = load double, double* %173
%175 = fmul double %170, %174
%176 = fneg double %166
%177 = call double @llvm.fmuladd.f64(double %176, double %175, double %162)
%178 = fneg double %177
store double %178, double* %9
%179 = load [3 x double]*, [3 x double]** %5
%180 = getelementptr inbounds [3 x double], [3 x double]* %179, i64 0
%181 = getelementptr inbounds [3 x double], [3 x double]* %180, i64 0, i64 0
%182 = load double, double* %181
%183 = load [3 x double]*, [3 x double]** %5
%184 = getelementptr inbounds [3 x double], [3 x double]* %183, i64 1
%185 = getelementptr inbounds [3 x double], [3 x double]* %184, i64 0, i64 1
%186 = load double, double* %185
%187 = load [3 x double]*, [3 x double]** %5
%188 = getelementptr inbounds [3 x double], [3 x double]* %187, i64 0
%189 = getelementptr inbounds [3 x double], [3 x double]* %188, i64 0, i64 1
%190 = load double, double* %189
%191 = load [3 x double]*, [3 x double]** %5
%192 = getelementptr inbounds [3 x double], [3 x double]* %191, i64 0
%193 = getelementptr inbounds [3 x double], [3 x double]* %192, i64 0, i64 1
%194 = load double, double* %193
%195 = fmul double %190, %194
%196 = fneg double %195
%197 = call double @llvm.fmuladd.f64(double %182, double %186, double %196)
%198 = load [3 x double]*, [3 x double]** %5
%199 = getelementptr inbounds [3 x double], [3 x double]* %198, 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 double]*, [3 x double]** %5
%203 = getelementptr inbounds [3 x double], [3 x double]* %202, i64 2
%204 = getelementptr inbounds [3 x double], [3 x double]* %203, i64 0, i64 2
%205 = load double, double* %204
%206 = call double @llvm.fmuladd.f64(double %201, double %205, double %197)
%207 = load [3 x double]*, [3 x double]** %5
%208 = getelementptr inbounds [3 x double], [3 x double]* %207, i64 0
%209 = getelementptr inbounds [3 x double], [3 x double]* %208, i64 0, i64 2
%210 = load double, double* %209
%211 = load [3 x double]*, [3 x double]** %5
%212 = getelementptr inbounds [3 x double], [3 x double]* %211, i64 0
%213 = getelementptr inbounds [3 x double], [3 x double]* %212, i64 0, i64 2
%214 = load double, double* %213
%215 = fneg double %210
%216 = call double @llvm.fmuladd.f64(double %215, double %214, double %206)
%217 = load [3 x double]*, [3 x double]** %5
%218 = getelementptr inbounds [3 x double], [3 x double]* %217, i64 1
%219 = getelementptr inbounds [3 x double], [3 x double]* %218, i64 0, i64 1
%220 = load double, double* %219
%221 = load [3 x double]*, [3 x double]** %5
%222 = getelementptr inbounds [3 x double], [3 x double]* %221, i64 2
%223 = getelementptr inbounds [3 x double], [3 x double]* %222, i64 0, i64 2
%224 = load double, double* %223
%225 = call double @llvm.fmuladd.f64(double %220, double %224, double %216)
%226 = load [3 x double]*, [3 x double]** %5
%227 = getelementptr inbounds [3 x double], [3 x double]* %226, i64 1
%228 = getelementptr inbounds [3 x double], [3 x double]* %227, i64 0, i64 2
%229 = load double, double* %228
%230 = load [3 x double]*, [3 x double]** %5
%231 = getelementptr inbounds [3 x double], [3 x double]* %230, i64 1
%232 = getelementptr inbounds [3 x double], [3 x double]* %231, i64 0, i64 2
%233 = load double, double* %232
%234 = fneg double %229
%235 = call double @llvm.fmuladd.f64(double %234, double %233, double %225)
store double %235, double* %10
%236 = load [3 x double]*, [3 x double]** %5
%237 = getelementptr inbounds [3 x double], [3 x double]* %236, i64 0
%238 = getelementptr inbounds [3 x double], [3 x double]* %237, i64 0, i64 0
%239 = load double, double* %238
%240 = load [3 x double]*, [3 x double]** %5
%241 = getelementptr inbounds [3 x double], [3 x double]* %240, i64 1
%242 = getelementptr inbounds [3 x double], [3 x double]* %241, i64 0, i64 1
%243 = load double, double* %242
%244 = fadd double %239, %243
%245 = load [3 x double]*, [3 x double]** %5
%246 = getelementptr inbounds [3 x double], [3 x double]* %245, i64 2
%247 = getelementptr inbounds [3 x double], [3 x double]* %246, i64 0, i64 2
%248 = load double, double* %247
%249 = fadd double %244, %248
%250 = fneg double %249
store double %250, double* %11
%251 = load double*, double** %7
%252 = load double, double* %9
%253 = load double, double* %10
%254 = load double, double* %11
%255 = call i32 (double*, double, double, double, ...) bitcast (i32 (...)* @roots3 to i32 (double*, double, double, double, ...)*)(double* %251, double %252, double %253, double %254)
%256 = load double*, double** %7
%257 = getelementptr inbounds double, double* %256, i64 0
%258 = load double, double* %257
%259 = load double*, double** %7
%260 = getelementptr inbounds double, double* %259, i64 0
%261 = load double, double* %260
%262 = fneg double %261
%263 = fcmp ogt double %258, %262
br i1 %263, label %264, label %268
264: ; preds = %103
%265 = load double*, double** %7
%266 = getelementptr inbounds double, double* %265, i64 0
%267 = load double, double* %266
br label %273
268: ; preds = %103
%269 = load double*, double** %7
%270 = getelementptr inbounds double, double* %269, i64 0
%271 = load double, double* %270
%272 = fneg double %271
br label %273
273: ; preds = %268, %264
%274 = phi double [ %267, %264 ], [ %272, %268 ]
%275 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 0
store double %274, double* %275
%276 = load double*, double** %7
%277 = getelementptr inbounds double, double* %276, i64 1
%278 = load double, double* %277
%279 = load double*, double** %7
%280 = getelementptr inbounds double, double* %279, i64 1
%281 = load double, double* %280
%282 = fneg double %281
%283 = fcmp ogt double %278, %282
br i1 %283, label %284, label %288
284: ; preds = %273
%285 = load double*, double** %7
%286 = getelementptr inbounds double, double* %285, i64 1
%287 = load double, double* %286
br label %293
288: ; preds = %273
%289 = load double*, double** %7
%290 = getelementptr inbounds double, double* %289, i64 1
%291 = load double, double* %290
%292 = fneg double %291
br label %293
293: ; preds = %288, %284
%294 = phi double [ %287, %284 ], [ %292, %288 ]
%295 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 1
store double %294, double* %295
%296 = load double*, double** %7
%297 = getelementptr inbounds double, double* %296, i64 2
%298 = load double, double* %297
%299 = load double*, double** %7
%300 = getelementptr inbounds double, double* %299, i64 2
%301 = load double, double* %300
%302 = fneg double %301
%303 = fcmp ogt double %298, %302
br i1 %303, label %304, label %308
304: ; preds = %293
%305 = load double*, double** %7
%306 = getelementptr inbounds double, double* %305, i64 2
%307 = load double, double* %306
br label %313
308: ; preds = %293
%309 = load double*, double** %7
%310 = getelementptr inbounds double, double* %309, i64 2
%311 = load double, double* %310
%312 = fneg double %311
br label %313
313: ; preds = %308, %304
%314 = phi double [ %307, %304 ], [ %312, %308 ]
%315 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 2
store double %314, double* %315
%316 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 0
%317 = load double, double* %316
%318 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 1
%319 = load double, double* %318
%320 = fcmp oge double %317, %319
br i1 %320, label %321, label %347
321: ; preds = %313
%322 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 0
%323 = load double, double* %322
%324 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 2
%325 = load double, double* %324
%326 = fcmp ogt double %323, %325
br i1 %326, label %327, label %346
327: ; preds = %321
%328 = load double*, double** %7
%329 = getelementptr inbounds double, double* %328, i64 0
%330 = load double, double* %329
store double %330, double* %16
%331 = load double*, double** %7
%332 = getelementptr inbounds double, double* %331, i64 2
%333 = load double, double* %332
%334 = load double*, double** %7
%335 = getelementptr inbounds double, double* %334, i64 0
store double %333, double* %335
%336 = load double, double* %16
%337 = load double*, double** %7
%338 = getelementptr inbounds double, double* %337, i64 2
store double %336, double* %338
%339 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 0
%340 = load double, double* %339
store double %340, double* %16
%341 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 2
%342 = load double, double* %341
%343 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 0
store double %342, double* %343
%344 = load double, double* %16
%345 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 2
store double %344, double* %345
br label %346
346: ; preds = %327, %321
br label %373
347: ; preds = %313
%348 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 1
%349 = load double, double* %348
%350 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 2
%351 = load double, double* %350
%352 = fcmp ogt double %349, %351
br i1 %352, label %353, label %372
353: ; preds = %347
%354 = load double*, double** %7
%355 = getelementptr inbounds double, double* %354, i64 1
%356 = load double, double* %355
store double %356, double* %16
%357 = load double*, double** %7
%358 = getelementptr inbounds double, double* %357, i64 2
%359 = load double, double* %358
%360 = load double*, double** %7
%361 = getelementptr inbounds double, double* %360, i64 1
store double %359, double* %361
%362 = load double, double* %16
%363 = load double*, double** %7
%364 = getelementptr inbounds double, double* %363, i64 2
store double %362, double* %364
%365 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 1
%366 = load double, double* %365
store double %366, double* %16
%367 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 2
%368 = load double, double* %367
%369 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 1
store double %368, double* %369
%370 = load double, double* %16
%371 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 2
store double %370, double* %371
br label %372
372: ; preds = %353, %347
br label %373
373: ; preds = %372, %346
%374 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 0
%375 = load double, double* %374
%376 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 1
%377 = load double, double* %376
%378 = fcmp oge double %375, %377
br i1 %378, label %379, label %398
379: ; preds = %373
%380 = load double*, double** %7
%381 = getelementptr inbounds double, double* %380, i64 0
%382 = load double, double* %381
store double %382, double* %16
%383 = load double*, double** %7
%384 = getelementptr inbounds double, double* %383, i64 1
%385 = load double, double* %384
%386 = load double*, double** %7
%387 = getelementptr inbounds double, double* %386, i64 0
store double %385, double* %387
%388 = load double, double* %16
%389 = load double*, double** %7
%390 = getelementptr inbounds double, double* %389, i64 1
store double %388, double* %390
%391 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 0
%392 = load double, double* %391
store double %392, double* %16
%393 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 1
%394 = load double, double* %393
%395 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 0
store double %394, double* %395
%396 = load double, double* %16
%397 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 1
store double %396, double* %397
br label %398
398: ; preds = %379, %373
%399 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 1
%400 = load double, double* %399
%401 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 0
%402 = load double, double* %401
%403 = fsub double %400, %402
%404 = fcmp olt double %403, 0x3D719799812DEA11
br i1 %404, label %405, label %406
405: ; preds = %398
store i32 0, i32* %4
br label %730
406: ; preds = %398
%407 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 2
%408 = load double, double* %407
%409 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 1
%410 = load double, double* %409
%411 = fsub double %408, %410
%412 = fcmp olt double %411, 0x3D719799812DEA11
br i1 %412, label %413, label %414
413: ; preds = %406
store i32 0, i32* %4
br label %730
414: ; preds = %406
%415 = load [3 x double]*, [3 x double]** %5
%416 = getelementptr inbounds [3 x double], [3 x double]* %415, i64 0
%417 = getelementptr inbounds [3 x double], [3 x double]* %416, i64 0, i64 1
%418 = load double, double* %417
%419 = load [3 x double]*, [3 x double]** %5
%420 = getelementptr inbounds [3 x double], [3 x double]* %419, i64 1
%421 = getelementptr inbounds [3 x double], [3 x double]* %420, i64 0, i64 2
%422 = load double, double* %421
%423 = fmul double %418, %422
store double %423, double* %17
%424 = load [3 x double]*, [3 x double]** %5
%425 = getelementptr inbounds [3 x double], [3 x double]* %424, i64 0
%426 = getelementptr inbounds [3 x double], [3 x double]* %425, i64 0, i64 1
%427 = load double, double* %426
%428 = load [3 x double]*, [3 x double]** %5
%429 = getelementptr inbounds [3 x double], [3 x double]* %428, i64 0
%430 = getelementptr inbounds [3 x double], [3 x double]* %429, i64 0, i64 2
%431 = load double, double* %430
%432 = fmul double %427, %431
store double %432, double* %18
%433 = load [3 x double]*, [3 x double]** %5
%434 = getelementptr inbounds [3 x double], [3 x double]* %433, i64 0
%435 = getelementptr inbounds [3 x double], [3 x double]* %434, i64 0, i64 1
%436 = load double, double* %435
%437 = load [3 x double]*, [3 x double]** %5
%438 = getelementptr inbounds [3 x double], [3 x double]* %437, i64 0
%439 = getelementptr inbounds [3 x double], [3 x double]* %438, i64 0, i64 1
%440 = load double, double* %439
%441 = fmul double %436, %440
store double %441, double* %19
%442 = load [3 x double]*, [3 x double]** %5
%443 = getelementptr inbounds [3 x double], [3 x double]* %442, i64 0
%444 = getelementptr inbounds [3 x double], [3 x double]* %443, i64 0, i64 0
%445 = load double, double* %444
%446 = load double*, double** %7
%447 = getelementptr inbounds double, double* %446, i64 0
%448 = load double, double* %447
%449 = fsub double %445, %448
store double %449, double* %20
%450 = load [3 x double]*, [3 x double]** %5
%451 = getelementptr inbounds [3 x double], [3 x double]* %450, i64 1
%452 = getelementptr inbounds [3 x double], [3 x double]* %451, i64 0, i64 1
%453 = load double, double* %452
%454 = load double*, double** %7
%455 = getelementptr inbounds double, double* %454, i64 0
%456 = load double, double* %455
%457 = fsub double %453, %456
store double %457, double* %21
%458 = load double, double* %17
%459 = load [3 x double]*, [3 x double]** %5
%460 = getelementptr inbounds [3 x double], [3 x double]* %459, i64 0
%461 = getelementptr inbounds [3 x double], [3 x double]* %460, i64 0, i64 2
%462 = load double, double* %461
%463 = load double, double* %21
%464 = fneg double %462
%465 = call double @llvm.fmuladd.f64(double %464, double %463, double %458)
%466 = load [3 x double]*, [3 x double]** %6
%467 = getelementptr inbounds [3 x double], [3 x double]* %466, i64 0
%468 = getelementptr inbounds [3 x double], [3 x double]* %467, i64 0, i64 0
store double %465, double* %468
%469 = load double, double* %18
%470 = load [3 x double]*, [3 x double]** %5
%471 = getelementptr inbounds [3 x double], [3 x double]* %470, i64 1
%472 = getelementptr inbounds [3 x double], [3 x double]* %471, i64 0, i64 2
%473 = load double, double* %472
%474 = load double, double* %20
%475 = fneg double %473
%476 = call double @llvm.fmuladd.f64(double %475, double %474, double %469)
%477 = load [3 x double]*, [3 x double]** %6
%478 = getelementptr inbounds [3 x double], [3 x double]* %477, i64 1
%479 = getelementptr inbounds [3 x double], [3 x double]* %478, i64 0, i64 0
store double %476, double* %479
%480 = load double, double* %20
%481 = load double, double* %21
%482 = load double, double* %19
%483 = fneg double %482
%484 = call double @llvm.fmuladd.f64(double %480, double %481, double %483)
%485 = load [3 x double]*, [3 x double]** %6
%486 = getelementptr inbounds [3 x double], [3 x double]* %485, i64 2
%487 = getelementptr inbounds [3 x double], [3 x double]* %486, i64 0, i64 0
store double %484, double* %487
%488 = load [3 x double]*, [3 x double]** %5
%489 = getelementptr inbounds [3 x double], [3 x double]* %488, i64 0
%490 = getelementptr inbounds [3 x double], [3 x double]* %489, i64 0, i64 0
%491 = load double, double* %490
%492 = load double*, double** %7
%493 = getelementptr inbounds double, double* %492, i64 1
%494 = load double, double* %493
%495 = fsub double %491, %494
store double %495, double* %20
%496 = load [3 x double]*, [3 x double]** %5
%497 = getelementptr inbounds [3 x double], [3 x double]* %496, i64 1
%498 = getelementptr inbounds [3 x double], [3 x double]* %497, i64 0, i64 1
%499 = load double, double* %498
%500 = load double*, double** %7
%501 = getelementptr inbounds double, double* %500, i64 1
%502 = load double, double* %501
%503 = fsub double %499, %502
store double %503, double* %21
%504 = load double, double* %17
%505 = load [3 x double]*, [3 x double]** %5
%506 = getelementptr inbounds [3 x double], [3 x double]* %505, i64 0
%507 = getelementptr inbounds [3 x double], [3 x double]* %506, i64 0, i64 2
%508 = load double, double* %507
%509 = load double, double* %21
%510 = fneg double %508
%511 = call double @llvm.fmuladd.f64(double %510, double %509, double %504)
%512 = load [3 x double]*, [3 x double]** %6
%513 = getelementptr inbounds [3 x double], [3 x double]* %512, i64 0
%514 = getelementptr inbounds [3 x double], [3 x double]* %513, i64 0, i64 1
store double %511, double* %514
%515 = load double, double* %18
%516 = load [3 x double]*, [3 x double]** %5
%517 = getelementptr inbounds [3 x double], [3 x double]* %516, i64 1
%518 = getelementptr inbounds [3 x double], [3 x double]* %517, i64 0, i64 2
%519 = load double, double* %518
%520 = load double, double* %20
%521 = fneg double %519
%522 = call double @llvm.fmuladd.f64(double %521, double %520, double %515)
%523 = load [3 x double]*, [3 x double]** %6
%524 = getelementptr inbounds [3 x double], [3 x double]* %523, i64 1
%525 = getelementptr inbounds [3 x double], [3 x double]* %524, i64 0, i64 1
store double %522, double* %525
%526 = load double, double* %20
%527 = load double, double* %21
%528 = load double, double* %19
%529 = fneg double %528
%530 = call double @llvm.fmuladd.f64(double %526, double %527, double %529)
%531 = load [3 x double]*, [3 x double]** %6
%532 = getelementptr inbounds [3 x double], [3 x double]* %531, i64 2
%533 = getelementptr inbounds [3 x double], [3 x double]* %532, i64 0, i64 1
store double %530, double* %533
%534 = load [3 x double]*, [3 x double]** %5
%535 = getelementptr inbounds [3 x double], [3 x double]* %534, i64 0
%536 = getelementptr inbounds [3 x double], [3 x double]* %535, i64 0, i64 0
%537 = load double, double* %536
%538 = load double*, double** %7
%539 = getelementptr inbounds double, double* %538, i64 2
%540 = load double, double* %539
%541 = fsub double %537, %540
store double %541, double* %20
%542 = load [3 x double]*, [3 x double]** %5
%543 = getelementptr inbounds [3 x double], [3 x double]* %542, i64 1
%544 = getelementptr inbounds [3 x double], [3 x double]* %543, i64 0, i64 1
%545 = load double, double* %544
%546 = load double*, double** %7
%547 = getelementptr inbounds double, double* %546, i64 2
%548 = load double, double* %547
%549 = fsub double %545, %548
store double %549, double* %21
%550 = load double, double* %17
%551 = load [3 x double]*, [3 x double]** %5
%552 = getelementptr inbounds [3 x double], [3 x double]* %551, i64 0
%553 = getelementptr inbounds [3 x double], [3 x double]* %552, i64 0, i64 2
%554 = load double, double* %553
%555 = load double, double* %21
%556 = fneg double %554
%557 = call double @llvm.fmuladd.f64(double %556, double %555, double %550)
%558 = load [3 x double]*, [3 x double]** %6
%559 = getelementptr inbounds [3 x double], [3 x double]* %558, i64 0
%560 = getelementptr inbounds [3 x double], [3 x double]* %559, i64 0, i64 2
store double %557, double* %560
%561 = load double, double* %18
%562 = load [3 x double]*, [3 x double]** %5
%563 = getelementptr inbounds [3 x double], [3 x double]* %562, i64 1
%564 = getelementptr inbounds [3 x double], [3 x double]* %563, i64 0, i64 2
%565 = load double, double* %564
%566 = load double, double* %20
%567 = fneg double %565
%568 = call double @llvm.fmuladd.f64(double %567, double %566, double %561)
%569 = load [3 x double]*, [3 x double]** %6
%570 = getelementptr inbounds [3 x double], [3 x double]* %569, i64 1
%571 = getelementptr inbounds [3 x double], [3 x double]* %570, i64 0, i64 2
store double %568, double* %571
%572 = load double, double* %20
%573 = load double, double* %21
%574 = load double, double* %19
%575 = fneg double %574
%576 = call double @llvm.fmuladd.f64(double %572, double %573, double %575)
%577 = load [3 x double]*, [3 x double]** %6
%578 = getelementptr inbounds [3 x double], [3 x double]* %577, i64 2
%579 = getelementptr inbounds [3 x double], [3 x double]* %578, i64 0, i64 2
store double %576, double* %579
%580 = load [3 x double]*, [3 x double]** %6
%581 = getelementptr inbounds [3 x double], [3 x double]* %580, i64 0
%582 = getelementptr inbounds [3 x double], [3 x double]* %581, i64 0, i64 0
%583 = load double, double* %582
%584 = load [3 x double]*, [3 x double]** %6
%585 = getelementptr inbounds [3 x double], [3 x double]* %584, i64 0
%586 = getelementptr inbounds [3 x double], [3 x double]* %585, i64 0, i64 0
%587 = load double, double* %586
%588 = load [3 x double]*, [3 x double]** %6
%589 = getelementptr inbounds [3 x double], [3 x double]* %588, i64 1
%590 = getelementptr inbounds [3 x double], [3 x double]* %589, i64 0, i64 0
%591 = load double, double* %590
%592 = load [3 x double]*, [3 x double]** %6
%593 = getelementptr inbounds [3 x double], [3 x double]* %592, i64 1
%594 = getelementptr inbounds [3 x double], [3 x double]* %593, i64 0, i64 0
%595 = load double, double* %594
%596 = fmul double %591, %595
%597 = call double @llvm.fmuladd.f64(double %583, double %587, double %596)
%598 = load [3 x double]*, [3 x double]** %6
%599 = getelementptr inbounds [3 x double], [3 x double]* %598, i64 2
%600 = getelementptr inbounds [3 x double], [3 x double]* %599, i64 0, i64 0
%601 = load double, double* %600
%602 = load [3 x double]*, [3 x double]** %6
%603 = getelementptr inbounds [3 x double], [3 x double]* %602, i64 2
%604 = getelementptr inbounds [3 x double], [3 x double]* %603, i64 0, i64 0
%605 = load double, double* %604
%606 = call double @llvm.fmuladd.f64(double %601, double %605, double %597)
%607 = call double @sqrt(double %606)
store double %607, double* %13
%608 = load [3 x double]*, [3 x double]** %6
%609 = getelementptr inbounds [3 x double], [3 x double]* %608, i64 0
%610 = getelementptr inbounds [3 x double], [3 x double]* %609, i64 0, i64 1
%611 = load double, double* %610
%612 = load [3 x double]*, [3 x double]** %6
%613 = getelementptr inbounds [3 x double], [3 x double]* %612, i64 0
%614 = getelementptr inbounds [3 x double], [3 x double]* %613, i64 0, i64 1
%615 = load double, double* %614
%616 = load [3 x double]*, [3 x double]** %6
%617 = getelementptr inbounds [3 x double], [3 x double]* %616, i64 1
%618 = getelementptr inbounds [3 x double], [3 x double]* %617, i64 0, i64 1
%619 = load double, double* %618
%620 = load [3 x double]*, [3 x double]** %6
%621 = getelementptr inbounds [3 x double], [3 x double]* %620, i64 1
%622 = getelementptr inbounds [3 x double], [3 x double]* %621, i64 0, i64 1
%623 = load double, double* %622
%624 = fmul double %619, %623
%625 = call double @llvm.fmuladd.f64(double %611, double %615, double %624)
%626 = load [3 x double]*, [3 x double]** %6
%627 = getelementptr inbounds [3 x double], [3 x double]* %626, i64 2
%628 = getelementptr inbounds [3 x double], [3 x double]* %627, i64 0, i64 1
%629 = load double, double* %628
%630 = load [3 x double]*, [3 x double]** %6
%631 = getelementptr inbounds [3 x double], [3 x double]* %630, i64 2
%632 = getelementptr inbounds [3 x double], [3 x double]* %631, i64 0, i64 1
%633 = load double, double* %632
%634 = call double @llvm.fmuladd.f64(double %629, double %633, double %625)
%635 = call double @sqrt(double %634)
store double %635, double* %14
%636 = load [3 x double]*, [3 x double]** %6
%637 = getelementptr inbounds [3 x double], [3 x double]* %636, i64 0
%638 = getelementptr inbounds [3 x double], [3 x double]* %637, i64 0, i64 2
%639 = load double, double* %638
%640 = load [3 x double]*, [3 x double]** %6
%641 = getelementptr inbounds [3 x double], [3 x double]* %640, i64 0
%642 = getelementptr inbounds [3 x double], [3 x double]* %641, i64 0, i64 2
%643 = load double, double* %642
%644 = load [3 x double]*, [3 x double]** %6
%645 = getelementptr inbounds [3 x double], [3 x double]* %644, i64 1
%646 = getelementptr inbounds [3 x double], [3 x double]* %645, i64 0, i64 2
%647 = load double, double* %646
%648 = load [3 x double]*, [3 x double]** %6
%649 = getelementptr inbounds [3 x double], [3 x double]* %648, i64 1
%650 = getelementptr inbounds [3 x double], [3 x double]* %649, i64 0, i64 2
%651 = load double, double* %650
%652 = fmul double %647, %651
%653 = call double @llvm.fmuladd.f64(double %639, double %643, double %652)
%654 = load [3 x double]*, [3 x double]** %6
%655 = getelementptr inbounds [3 x double], [3 x double]* %654, i64 2
%656 = getelementptr inbounds [3 x double], [3 x double]* %655, i64 0, i64 2
%657 = load double, double* %656
%658 = load [3 x double]*, [3 x double]** %6
%659 = getelementptr inbounds [3 x double], [3 x double]* %658, i64 2
%660 = getelementptr inbounds [3 x double], [3 x double]* %659, i64 0, i64 2
%661 = load double, double* %660
%662 = call double @llvm.fmuladd.f64(double %657, double %661, double %653)
%663 = call double @sqrt(double %662)
store double %663, double* %15
%664 = load double, double* %13
%665 = fcmp olt double %664, 0x3D719799812DEA11
br i1 %665, label %666, label %667
666: ; preds = %414
store i32 0, i32* %4
br label %730
667: ; preds = %414
%668 = load double, double* %14
%669 = fcmp olt double %668, 0x3D719799812DEA11
br i1 %669, label %670, label %671
670: ; preds = %667
store i32 0, i32* %4
br label %730
671: ; preds = %667
%672 = load double, double* %15
%673 = fcmp olt double %672, 0x3D719799812DEA11
br i1 %673, label %674, label %675
674: ; preds = %671
store i32 0, i32* %4
br label %730
675: ; preds = %671
%676 = load double, double* %13
%677 = load [3 x double]*, [3 x double]** %6
%678 = getelementptr inbounds [3 x double], [3 x double]* %677, i64 0
%679 = getelementptr inbounds [3 x double], [3 x double]* %678, i64 0, i64 0
%680 = load double, double* %679
%681 = fdiv double %680, %676
store double %681, double* %679
%682 = load double, double* %14
%683 = load [3 x double]*, [3 x double]** %6
%684 = getelementptr inbounds [3 x double], [3 x double]* %683, i64 0
%685 = getelementptr inbounds [3 x double], [3 x double]* %684, i64 0, i64 1
%686 = load double, double* %685
%687 = fdiv double %686, %682
store double %687, double* %685
%688 = load double, double* %15
%689 = load [3 x double]*, [3 x double]** %6
%690 = getelementptr inbounds [3 x double], [3 x double]* %689, i64 0
%691 = getelementptr inbounds [3 x double], [3 x double]* %690, i64 0, i64 2
%692 = load double, double* %691
%693 = fdiv double %692, %688
store double %693, double* %691
%694 = load double, double* %13
%695 = load [3 x double]*, [3 x double]** %6
%696 = getelementptr inbounds [3 x double], [3 x double]* %695, i64 1
%697 = getelementptr inbounds [3 x double], [3 x double]* %696, i64 0, i64 0
%698 = load double, double* %697
%699 = fdiv double %698, %694
store double %699, double* %697
%700 = load double, double* %14
%701 = load [3 x double]*, [3 x double]** %6
%702 = getelementptr inbounds [3 x double], [3 x double]* %701, i64 1
%703 = getelementptr inbounds [3 x double], [3 x double]* %702, i64 0, i64 1
%704 = load double, double* %703
%705 = fdiv double %704, %700
store double %705, double* %703
%706 = load double, double* %15
%707 = load [3 x double]*, [3 x double]** %6
%708 = getelementptr inbounds [3 x double], [3 x double]* %707, i64 1
%709 = getelementptr inbounds [3 x double], [3 x double]* %708, i64 0, i64 2
%710 = load double, double* %709
%711 = fdiv double %710, %706
store double %711, double* %709
%712 = load double, double* %13
%713 = load [3 x double]*, [3 x double]** %6
%714 = getelementptr inbounds [3 x double], [3 x double]* %713, i64 2
%715 = getelementptr inbounds [3 x double], [3 x double]* %714, i64 0, i64 0
%716 = load double, double* %715
%717 = fdiv double %716, %712
store double %717, double* %715
%718 = load double, double* %14
%719 = load [3 x double]*, [3 x double]** %6
%720 = getelementptr inbounds [3 x double], [3 x double]* %719, i64 2
%721 = getelementptr inbounds [3 x double], [3 x double]* %720, i64 0, i64 1
%722 = load double, double* %721
%723 = fdiv double %722, %718
store double %723, double* %721
%724 = load double, double* %15
%725 = load [3 x double]*, [3 x double]** %6
%726 = getelementptr inbounds [3 x double], [3 x double]* %725, i64 2
%727 = getelementptr inbounds [3 x double], [3 x double]* %726, i64 0, i64 2
%728 = load double, double* %727
%729 = fdiv double %728, %724
store double %729, double* %727
store i32 1, i32* %4
br label %730
730: ; preds = %675, %674, %670, %666, %413, %405, %102
%731 = load i32, i32* %4
ret i32 %731
}

LLVM IR (-O2):
define i32 @fast_eigen3x3([3 x double]* nocapture %0, [3 x double]* nocapture %1, double* %2) {
%4 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 0, i64 1
%5 = load double, double* %4
%6 = fneg double %5
%7 = fcmp ogt double %5, %6
%8 = select i1 %7, double %5, double %6
%9 = fcmp olt double %8, 0x3D719799812DEA11
%10 = zext i1 %9 to i32
%11 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 0, i64 2
%12 = load double, double* %11
%13 = fneg double %12
%14 = fcmp ogt double %12, %13
%15 = select i1 %14, double %12, double %13
%16 = fcmp olt double %15, 0x3D719799812DEA11
%17 = zext i1 %16 to i32
%18 = add nuw nsw i32 %17, %10
%19 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 1, i64 2
%20 = load double, double* %19
%21 = fneg double %20
%22 = fcmp ogt double %20, %21
%23 = select i1 %22, double %20, double %21
%24 = fcmp olt double %23, 0x3D719799812DEA11
%25 = zext i1 %24 to i32
%26 = add nuw nsw i32 %18, %25
%27 = icmp ugt i32 %26, 1
br i1 %27, label %203, label %28
28: ; preds = %3
%29 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 0, i64 0
%30 = load double, double* %29
%31 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 1, i64 1
%32 = load double, double* %31
%33 = fmul double %30, %32
%34 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 2, i64 2
%35 = load double, double* %34
%36 = fmul double %5, 2.000000e+00
%37 = fmul double %36, %12
%38 = fmul double %37, %20
%39 = tail call double @llvm.fmuladd.f64(double %33, double %35, double %38)
%40 = fmul double %20, %20
%41 = fneg double %30
%42 = tail call double @llvm.fmuladd.f64(double %41, double %40, double %39)
%43 = fmul double %12, %12
%44 = fneg double %32
%45 = tail call double @llvm.fmuladd.f64(double %44, double %43, double %42)
%46 = fmul double %5, %5
%47 = fneg double %35
%48 = tail call double @llvm.fmuladd.f64(double %47, double %46, double %45)
%49 = fneg double %48
%50 = fneg double %46
%51 = tail call double @llvm.fmuladd.f64(double %30, double %32, double %50)
%52 = tail call double @llvm.fmuladd.f64(double %30, double %35, double %51)
%53 = tail call double @llvm.fmuladd.f64(double %13, double %12, double %52)
%54 = tail call double @llvm.fmuladd.f64(double %32, double %35, double %53)
%55 = tail call double @llvm.fmuladd.f64(double %21, double %20, double %54)
%56 = fadd double %30, %32
%57 = fadd double %56, %35
%58 = fneg double %57
%59 = tail call i32 (double*, double, double, double, ...) bitcast (i32 (...)* @roots3 to i32 (double*, double, double, double, ...)*)(double* %2, double %49, double %55, double %58)
%60 = load double, double* %2
%61 = fneg double %60
%62 = fcmp ogt double %60, %61
%63 = select i1 %62, double %60, double %61
%64 = getelementptr inbounds double, double* %2, i64 1
%65 = load double, double* %64
%66 = fneg double %65
%67 = fcmp ogt double %65, %66
%68 = select i1 %67, double %65, double %66
%69 = getelementptr inbounds double, double* %2, i64 2
%70 = load double, double* %69
%71 = fneg double %70
%72 = fcmp ogt double %70, %71
%73 = select i1 %72, double %70, double %71
%74 = fcmp ult double %63, %68
br i1 %74, label %77, label %75
75: ; preds = %28
%76 = fcmp ogt double %63, %73
br i1 %76, label %79, label %87
77: ; preds = %28
%78 = fcmp ogt double %68, %73
br i1 %78, label %79, label %87
79: ; preds = %77, %75
%80 = phi double* [ %2, %75 ], [ %64, %77 ]
%81 = phi double [ %60, %75 ], [ %65, %77 ]
%82 = phi double [ %65, %75 ], [ %70, %77 ]
%83 = phi double [ %70, %75 ], [ %60, %77 ]
%84 = phi double [ %63, %75 ], [ %68, %77 ]
%85 = phi double [ %68, %75 ], [ %73, %77 ]
%86 = phi double [ %73, %75 ], [ %63, %77 ]
store double %70, double* %80
store double %81, double* %69
br label %87
87: ; preds = %79, %77, %75
%88 = phi double [ %65, %75 ], [ %65, %77 ], [ %82, %79 ]
%89 = phi double [ %60, %75 ], [ %60, %77 ], [ %83, %79 ]
%90 = phi double [ %73, %75 ], [ %73, %77 ], [ %84, %79 ]
%91 = phi double [ %68, %75 ], [ %68, %77 ], [ %85, %79 ]
%92 = phi double [ %63, %75 ], [ %63, %77 ], [ %86, %79 ]
%93 = fcmp ult double %92, %91
br i1 %93, label %95, label %94
94: ; preds = %87
store double %88, double* %2
store double %89, double* %64
br label %95
95: ; preds = %94, %87
%96 = phi double [ %88, %94 ], [ %89, %87 ]
%97 = phi double [ %92, %94 ], [ %91, %87 ]
%98 = phi double [ %91, %94 ], [ %92, %87 ]
%99 = fsub double %97, %98
%100 = fcmp olt double %99, 0x3D719799812DEA11
%101 = fsub double %90, %97
%102 = fcmp olt double %101, 0x3D719799812DEA11
%103 = select i1 %100, i1 true, i1 %102
br i1 %103, label %203, label %104
104: ; preds = %95
%105 = load double, double* %4
%106 = load double, double* %19
%107 = fmul double %105, %106
%108 = load double, double* %11
%109 = fmul double %105, %108
%110 = load double, double* %29
%111 = fsub double %110, %96
%112 = load double, double* %31
%113 = fsub double %112, %96
%114 = fneg double %108
%115 = tail call double @llvm.fmuladd.f64(double %114, double %113, double %107)
%116 = getelementptr inbounds [3 x double], [3 x double]* %1, i64 0, i64 0
store double %115, double* %116
%117 = load double, double* %19
%118 = fneg double %117
%119 = tail call double @llvm.fmuladd.f64(double %118, double %111, double %109)
%120 = getelementptr inbounds [3 x double], [3 x double]* %1, i64 1, i64 0
store double %119, double* %120
%121 = fneg double %105
%122 = fmul double %105, %121
%123 = tail call double @llvm.fmuladd.f64(double %111, double %113, double %122)
%124 = getelementptr inbounds [3 x double], [3 x double]* %1, i64 2, i64 0
store double %123, double* %124
%125 = load double, double* %29
%126 = load double, double* %64
%127 = fsub double %125, %126
%128 = load double, double* %31
%129 = fsub double %128, %126
%130 = load double, double* %11
%131 = fneg double %130
%132 = tail call double @llvm.fmuladd.f64(double %131, double %129, double %107)
%133 = getelementptr inbounds [3 x double], [3 x double]* %1, i64 0, i64 1
store double %132, double* %133
%134 = load double, double* %19
%135 = fneg double %134
%136 = tail call double @llvm.fmuladd.f64(double %135, double %127, double %109)
%137 = getelementptr inbounds [3 x double], [3 x double]* %1, i64 1, i64 1
store double %136, double* %137
%138 = tail call double @llvm.fmuladd.f64(double %127, double %129, double %122)
%139 = getelementptr inbounds [3 x double], [3 x double]* %1, i64 2, i64 1
store double %138, double* %139
%140 = load double, double* %29
%141 = load double, double* %69
%142 = fsub double %140, %141
%143 = load double, double* %31
%144 = fsub double %143, %141
%145 = load double, double* %11
%146 = fneg double %145
%147 = tail call double @llvm.fmuladd.f64(double %146, double %144, double %107)
%148 = getelementptr inbounds [3 x double], [3 x double]* %1, i64 0, i64 2
store double %147, double* %148
%149 = load double, double* %19
%150 = fneg double %149
%151 = tail call double @llvm.fmuladd.f64(double %150, double %142, double %109)
%152 = getelementptr inbounds [3 x double], [3 x double]* %1, i64 1, i64 2
store double %151, double* %152
%153 = tail call double @llvm.fmuladd.f64(double %142, double %144, double %122)
%154 = getelementptr inbounds [3 x double], [3 x double]* %1, i64 2, i64 2
store double %153, double* %154
%155 = fmul double %119, %119
%156 = tail call double @llvm.fmuladd.f64(double %115, double %115, double %155)
%157 = tail call double @llvm.fmuladd.f64(double %123, double %123, double %156)
%158 = tail call double @sqrt(double %157)
%159 = load double, double* %133
%160 = load double, double* %137
%161 = fmul double %160, %160
%162 = tail call double @llvm.fmuladd.f64(double %159, double %159, double %161)
%163 = load double, double* %139
%164 = tail call double @llvm.fmuladd.f64(double %163, double %163, double %162)
%165 = tail call double @sqrt(double %164)
%166 = load double, double* %148
%167 = load double, double* %152
%168 = fmul double %167, %167
%169 = tail call double @llvm.fmuladd.f64(double %166, double %166, double %168)
%170 = load double, double* %154
%171 = tail call double @llvm.fmuladd.f64(double %170, double %170, double %169)
%172 = tail call double @sqrt(double %171)
%173 = fcmp olt double %158, 0x3D719799812DEA11
%174 = fcmp olt double %165, 0x3D719799812DEA11
%175 = select i1 %173, i1 true, i1 %174
%176 = fcmp olt double %172, 0x3D719799812DEA11
%177 = select i1 %175, i1 true, i1 %176
br i1 %177, label %203, label %178
178: ; preds = %104
%179 = bitcast [3 x double]* %1 to <2 x double>*
%180 = load <2 x double>, <2 x double>* %179
%181 = insertelement <2 x double> poison, double %158, i64 0
%182 = insertelement <2 x double> %181, double %165, i64 1
%183 = fdiv <2 x double> %180, %182
%184 = bitcast [3 x double]* %1 to <2 x double>*
store <2 x double> %183, <2 x double>* %184
%185 = bitcast double* %148 to <2 x double>*
%186 = load <2 x double>, <2 x double>* %185
%187 = insertelement <2 x double> poison, double %172, i64 0
%188 = insertelement <2 x double> %187, double %158, i64 1
%189 = fdiv <2 x double> %186, %188
%190 = bitcast double* %148 to <2 x double>*
store <2 x double> %189, <2 x double>* %190
%191 = bitcast double* %137 to <2 x double>*
%192 = load <2 x double>, <2 x double>* %191
%193 = insertelement <2 x double> poison, double %165, i64 0
%194 = insertelement <2 x double> %193, double %172, i64 1
%195 = fdiv <2 x double> %192, %194
%196 = bitcast double* %137 to <2 x double>*
store <2 x double> %195, <2 x double>* %196
%197 = bitcast double* %124 to <2 x double>*
%198 = load <2 x double>, <2 x double>* %197
%199 = fdiv <2 x double> %198, %182
%200 = bitcast double* %124 to <2 x double>*
store <2 x double> %199, <2 x double>* %200
%201 = load double, double* %154
%202 = fdiv double %201, %172
store double %202, double* %154
br label %203
203: ; preds = %104, %95, %3, %178
%204 = phi i32 [ 1, %178 ], [ 0, %3 ], [ 0, %95 ], [ 0, %104 ]
ret i32 %204
}