#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double fabs(double);
double sqrt(double);
int cvJacobiEigens_64d(double *A, double *V, double *E, int n, double eps) {
  int i, j, k, p, q, ind;
  double *A1 = A, *V1 = V, *A2 = A, *V2 = V;
  double Amax = 0.0, anorm = 0.0, ax, deps;
  if (eps < 1.0e-15)
    eps = 1.0e-15;
  deps = eps / (double)n;
  for (i = 0; i < n; i++, V1 += n, A1 += n) {
    for (j = 0; j < i; j++) {
      double Am = A1[j];
      anorm += Am * Am;
    }
    for (j = 0; j < n; j++)
      V1[j] = 0.0;
    V1[i] = 1.0;
  }
  anorm = sqrt(anorm + anorm);
  ax = anorm * eps / n;
  Amax = anorm;
  while (Amax > ax) {
    Amax /= n;
    do {
      ind = 0;
      A1 = A;
      V1 = V;
      for (p = 0; p < n - 1; p++, A1 += n, V1 += n) {
        A2 = A + n * (p + 1);
        V2 = V + n * (p + 1);
        for (q = p + 1; q < n; q++, A2 += n, V2 += n) {
          double x, y, c, s, c2, s2, a;
          double *A3, Apq, App, Aqq, App2, Aqq2, Aip, Aiq, Vpi, Vqi;
          if (fabs(A1[q]) < Amax)
            continue;
          Apq = A1[q];
          ind = 1;
          App = A1[p];
          Aqq = A2[q];
          y = 5.0e-1 * (App - Aqq);
          x = -Apq / sqrt(Apq * Apq + y * y);
          if (y < 0.0)
            x = -x;
          s = x / sqrt(2.0 * (1.0 + sqrt(1.0 - x * x)));
          s2 = s * s;
          c = sqrt(1.0 - s2);
          c2 = c * c;
          a = 2.0 * Apq * c * s;
          A3 = A;
          for (i = 0; i < p; i++, A3 += n) {
            Aip = A3[p];
            Aiq = A3[q];
            Vpi = V1[i];
            Vqi = V2[i];
            A3[p] = Aip * c - Aiq * s;
            A3[q] = Aiq * c + Aip * s;
            V1[i] = Vpi * c - Vqi * s;
            V2[i] = Vqi * c + Vpi * s;
          }
          for (; i < q; i++, A3 += n) {
            Aip = A1[i];
            Aiq = A3[q];
            Vpi = V1[i];
            Vqi = V2[i];
            A1[i] = Aip * c - Aiq * s;
            A3[q] = Aiq * c + Aip * s;
            V1[i] = Vpi * c - Vqi * s;
            V2[i] = Vqi * c + Vpi * s;
          }
          for (; i < n; i++) {
            Aip = A1[i];
            Aiq = A2[i];
            Vpi = V1[i];
            Vqi = V2[i];
            A1[i] = Aip * c - Aiq * s;
            A2[i] = Aiq * c + Aip * s;
            V1[i] = Vpi * c - Vqi * s;
            V2[i] = Vqi * c + Vpi * s;
          }
          App2 = App * c2 + Aqq * s2 - a;
          Aqq2 = App * s2 + Aqq * c2 + a;
          A1[p] = App2;
          A2[q] = Aqq2;
          A1[q] = A2[p] = 0.0;
        }
      }
    } while (ind);
  }
  for (i = 0, k = 0; i < n; i++, k += n + 1)
    E[i] = A[k];
  return 0;
}


x86 assembly (clang, -O0):
<cvJacobiEigens_64d>:
push   %rbp
mov    %rsp,%rbp
sub    $0x120,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
movsd  %xmm0,-0x28(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x60(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  0xe99(%rip),%xmm0
ucomisd -0x28(%rbp),%xmm0
jbe    117f <cvJacobiEigens_64d+0x6f>
movsd  0xe86(%rip),%xmm0
movsd  %xmm0,-0x28(%rbp)
movsd  -0x28(%rbp),%xmm0
cvtsi2sdl -0x1c(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    127b <cvJacobiEigens_64d+0x16b>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    11fd <cvJacobiEigens_64d+0xed>
mov    -0x48(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x88(%rbp),%xmm2
ff
movsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11ac <cvJacobiEigens_64d+0x9c>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    122e <cvJacobiEigens_64d+0x11e>
mov    -0x50(%rbp),%rax
movslq -0x30(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1204 <cvJacobiEigens_64d+0xf4>
mov    -0x50(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  0xdda(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x1c(%rbp),%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x1c(%rbp),%ecx
mov    -0x48(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
jmp    1199 <cvJacobiEigens_64d+0x89>
movsd  -0x70(%rbp),%xmm0
addsd  -0x70(%rbp),%xmm0
call   1030 <sqrt@plt>
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm0
mulsd  -0x28(%rbp),%xmm0
cvtsi2sdl -0x1c(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm0
ucomisd -0x78(%rbp),%xmm0
jbe    1b79 <cvJacobiEigens_64d+0xa69>
cvtsi2sdl -0x1c(%rbp),%xmm1
movsd  -0x68(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x50(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1b65 <cvJacobiEigens_64d+0xa55>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    -0x38(%rbp),%edx
add    $0x1,%edx
imul   %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    -0x38(%rbp),%edx
add    $0x1,%edx
imul   %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1b28 <cvJacobiEigens_64d+0xa18>
mov    -0x48(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0xcb8(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  -0x68(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1380 <cvJacobiEigens_64d+0x270>
jmp    1af0 <cvJacobiEigens_64d+0x9e0>
mov    -0x48(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movl   $0x1,-0x40(%rbp)
mov    -0x48(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x58(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0xd8(%rbp),%xmm1
ff
subsd  -0xe0(%rbp),%xmm1
ff
movsd  0xc2a(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
movsd  -0xd0(%rbp),%xmm2
ff
movsd  -0x98(%rbp),%xmm1
ff
mulsd  -0x98(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1030 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0x118(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
xorps  %xmm0,%xmm0
ucomisd -0x98(%rbp),%xmm0
ff
jbe    148d <cvJacobiEigens_64d+0x37d>
movsd  -0x90(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0x90(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm1,%xmm0
movsd  0xb48(%rip),%xmm1
addsd  %xmm1,%xmm0
call   1030 <sqrt@plt>
movsd  0xb37(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0xb23(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0x120(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
mulsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  0xaeb(%rip),%xmm0
subsd  -0xb8(%rbp),%xmm0
ff
call   1030 <sqrt@plt>
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
mulsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  0xaae(%rip),%xmm0
mulsd  -0xd0(%rbp),%xmm0
ff
mulsd  -0xa0(%rbp),%xmm0
ff
mulsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    %rax,-0xc8(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    172b <cvJacobiEigens_64d+0x61b>
mov    -0xc8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0xc8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
mov    -0x50(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
mov    -0x60(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
movsd  -0xf8(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0x100(%rbp),%xmm1
ff
mulsd  -0xa8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xc8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x100(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0xf8(%rbp),%xmm1
ff
mulsd  -0xa8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xc8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x108(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0x110(%rbp),%xmm1
ff
mulsd  -0xa8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x50(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x110(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0x108(%rbp),%xmm1
ff
mulsd  -0xa8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x60(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x1c(%rbp),%ecx
mov    -0xc8(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xc8(%rbp)
jmp    1594 <cvJacobiEigens_64d+0x484>
jmp    1730 <cvJacobiEigens_64d+0x620>
mov    -0x2c(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    18c1 <cvJacobiEigens_64d+0x7b1>
mov    -0x48(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0xc8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
mov    -0x50(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
mov    -0x60(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
movsd  -0xf8(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0x100(%rbp),%xmm1
ff
mulsd  -0xa8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x100(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0xf8(%rbp),%xmm1
ff
mulsd  -0xa8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xc8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x108(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0x110(%rbp),%xmm1
ff
mulsd  -0xa8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x50(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x110(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0x108(%rbp),%xmm1
ff
mulsd  -0xa8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x60(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x1c(%rbp),%ecx
mov    -0xc8(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xc8(%rbp)
jmp    1730 <cvJacobiEigens_64d+0x620>
jmp    18c6 <cvJacobiEigens_64d+0x7b6>
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1a36 <cvJacobiEigens_64d+0x926>
mov    -0x48(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x58(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
mov    -0x50(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
mov    -0x60(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
movsd  -0xf8(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0x100(%rbp),%xmm1
ff
mulsd  -0xa8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x100(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0xf8(%rbp),%xmm1
ff
mulsd  -0xa8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x58(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x108(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0x110(%rbp),%xmm1
ff
mulsd  -0xa8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x50(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x110(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0x108(%rbp),%xmm1
ff
mulsd  -0xa8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x60(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    18c6 <cvJacobiEigens_64d+0x7b6>
movsd  -0xd8(%rbp),%xmm0
ff
movsd  -0xb0(%rbp),%xmm2
ff
movsd  -0xe0(%rbp),%xmm1
ff
mulsd  -0xb8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
subsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
movsd  -0xb8(%rbp),%xmm2
ff
movsd  -0xe0(%rbp),%xmm1
ff
mulsd  -0xb0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
addsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
mov    -0x48(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xf0(%rbp),%xmm0
ff
mov    -0x58(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x58(%rbp),%rax
movslq -0x38(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%rax
movslq -0x3c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x1c(%rbp),%ecx
mov    -0x58(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x1c(%rbp),%ecx
mov    -0x60(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
jmp    1348 <cvJacobiEigens_64d+0x238>
jmp    1b2d <cvJacobiEigens_64d+0xa1d>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x1c(%rbp),%ecx
mov    -0x48(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x1c(%rbp),%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
jmp    12f2 <cvJacobiEigens_64d+0x1e2>
jmp    1b6a <cvJacobiEigens_64d+0xa5a>
cmpl   $0x0,-0x40(%rbp)
jne    12d4 <cvJacobiEigens_64d+0x1c4>
jmp    12b1 <cvJacobiEigens_64d+0x1a1>
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1bc7 <cvJacobiEigens_64d+0xab7>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    1b87 <cvJacobiEigens_64d+0xa77>
xor    %eax,%eax
add    $0x120,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<cvJacobiEigens_64d>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xf8,%rsp
movsd  %xmm0,0x80(%rsp)
mov    %rdx,%r12
mov    %rsi,0x60(%rsp)
mov    %rdi,0x8(%rsp)
movsd  0xeb1(%rip),%xmm0
movsd  %xmm0,0x58(%rsp)
mov    %ecx,%edx
xorpd  %xmm2,%xmm2
test   %ecx,%ecx
mov    %rdx,0x30(%rsp)
mov    %rcx,0x38(%rsp)
jle    127b <cvJacobiEigens_64d+0x15b>
lea    0x0(,%rdx,8),%r13
xorpd  %xmm2,%xmm2
xor    %ebx,%ebx
movabs $0x3ff0000000000000,%r14
mov    0x8(%rsp),%rbp
mov    0x60(%rsp),%r15
jmp    11db <cvJacobiEigens_64d+0xbb>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  %xmm2,0x40(%rsp)
mov    %r15,%rdi
xor    %esi,%esi
mov    %r13,%rdx
call   1030 <memset@plt>
movsd  0x40(%rsp),%xmm2
mov    %r14,(%r15,%rbx,8)
add    $0x1,%rbx
mov    0x30(%rsp),%rdx
lea    (%r15,%rdx,8),%r15
add    %r13,%rbp
cmp    %rdx,%rbx
mov    0x38(%rsp),%rcx
je     127b <cvJacobiEigens_64d+0x15b>
test   %rbx,%rbx
je     11a0 <cvJacobiEigens_64d+0x80>
lea    -0x1(%rbx),%rax
cmp    $0x3,%rax
jae    11f0 <cvJacobiEigens_64d+0xd0>
xor    %eax,%eax
jmp    1241 <cvJacobiEigens_64d+0x121>
xchg   %ax,%ax
mov    %rbx,%rcx
and    $0xfffffffffffffffc,%rcx
xor    %eax,%eax
nopl   0x0(%rax)
movsd  0x0(%rbp,%rax,8),%xmm0
movsd  0x8(%rbp,%rax,8),%xmm1
mulsd  %xmm0,%xmm0
addsd  %xmm2,%xmm0
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  0x10(%rbp,%rax,8),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movsd  0x18(%rbp,%rax,8),%xmm2
mulsd  %xmm2,%xmm2
addsd  %xmm0,%xmm2
add    $0x4,%rax
cmp    %rax,%rcx
jne    1200 <cvJacobiEigens_64d+0xe0>
test   $0x3,%bl
je     11a0 <cvJacobiEigens_64d+0x80>
mov    %ebx,%ecx
and    $0x3,%ecx
lea    0x0(,%rax,8),%rax
add    %rbp,%rax
xor    %edx,%edx
nopl   0x0(%rax)
movsd  (%rax,%rdx,8),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm2
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    1260 <cvJacobiEigens_64d+0x140>
jmp    11a0 <cvJacobiEigens_64d+0x80>
xorps  %xmm0,%xmm0
cvtsi2sd %ecx,%xmm0
movsd  %xmm0,0x90(%rsp)
movsd  0x58(%rsp),%xmm0
maxsd  0x80(%rsp),%xmm0
movsd  %xmm0,0x58(%rsp)
addsd  %xmm2,%xmm2
ucomisd 0xd6c(%rip),%xmm2
mov    %r12,0xb8(%rsp)
jb     12bd <cvJacobiEigens_64d+0x19d>
sqrtsd %xmm2,%xmm9
jmp    12d5 <cvJacobiEigens_64d+0x1b5>
movapd %xmm2,%xmm0
call   1040 <sqrt@plt>
mov    0x38(%rsp),%rcx
mov    0x30(%rsp),%rdx
movapd %xmm0,%xmm9
movsd  0x58(%rsp),%xmm0
mulsd  %xmm9,%xmm0
divsd  0x90(%rsp),%xmm0
movsd  %xmm0,0x58(%rsp)
ucomisd %xmm0,%xmm9
jbe    1aa5 <cvJacobiEigens_64d+0x985>
lea    -0x1(%rcx),%eax
mov    %rax,0xc8(%rsp)
movslq %ecx,%r8
lea    0x1(%r8),%rax
mov    %rax,0xc0(%rsp)
lea    0x0(,%r8,8),%rax
mov    %rax,0x68(%rsp)
movapd 0xcf6(%rip),%xmm10
xorpd  %xmm11,%xmm11
mov    %r8,0x98(%rsp)
jmp    134d <cvJacobiEigens_64d+0x22d>
nopl   0x0(%rax)
ucomisd 0x58(%rsp),%xmm9
jbe    1aa5 <cvJacobiEigens_64d+0x985>
divsd  0x90(%rsp),%xmm9
cmp    $0x2,%ecx
jl     1340 <cvJacobiEigens_64d+0x220>
xor    %r12d,%r12d
mov    $0x1,%ebx
xor    %r9d,%r9d
mov    0x8(%rsp),%r15
mov    0x60(%rsp),%rbp
movsd  %xmm9,0xa0(%rsp)
nopl   0x0(%rax,%rax,1)
lea    0x1(%r12),%rax
cmp    %r8,%rax
mov    %rbx,0xd8(%rsp)
mov    %rax,0xd0(%rsp)
jge    1a40 <cvJacobiEigens_64d+0x920>
mov    %r12,%rsi
imul   %r8,%rsi
mov    0x8(%rsp),%r10
lea    (%r10,%rsi,8),%rdi
add    $0x8,%rdi
mov    %rdi,0xf0(%rsp)
mov    0xc0(%rsp),%rdi
add    %rsi,%rdi
mov    %rdi,0xe8(%rsp)
mov    0x60(%rsp),%rdi
lea    (%rdi,%rsi,8),%rsi
add    $0x8,%rsi
mov    %rsi,0xe0(%rsp)
mov    %rax,%rsi
imul   %r8,%rsi
lea    (%rdi,%rsi,8),%r14
lea    (%r10,%rsi,8),%rsi
lea    0x0(,%rbx,8),%rdi
xor    %r10d,%r10d
mov    0x68(%rsp),%r13
jmp    1494 <cvJacobiEigens_64d+0x374>
cs nopw 0x0(%rax,%rax,1)
addsd  %xmm12,%xmm12
mulsd  %xmm0,%xmm12
mulsd  %xmm0,%xmm0
mulsd  %xmm15,%xmm12
movapd %xmm14,%xmm1
mulsd  %xmm7,%xmm1
movapd %xmm13,%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm1,%xmm2
subsd  %xmm12,%xmm2
mulsd  %xmm14,%xmm0
mulsd  %xmm7,%xmm13
addsd  %xmm0,%xmm13
addsd  %xmm12,%xmm13
movsd  %xmm2,(%r15,%r12,8)
movsd  %xmm13,(%rsi,%rbx,8)
movq   $0x0,(%rsi,%r12,8)
movq   $0x0,(%r15,%rbx,8)
mov    $0x1,%r9d
mov    0x30(%rsp),%rdx
add    $0x1,%rbx
add    %r13,%rsi
add    %r13,%r14
add    $0x1,%r10
add    $0x8,%rdi
cmp    %rdx,%rbx
je     1a40 <cvJacobiEigens_64d+0x920>
movsd  (%r15,%rbx,8),%xmm2
movapd %xmm2,%xmm0
andpd  %xmm10,%xmm0
ucomisd %xmm0,%xmm9
ja     1479 <cvJacobiEigens_64d+0x359>
movsd  (%r15,%r12,8),%xmm3
movsd  (%rsi,%rbx,8),%xmm4
movapd %xmm3,%xmm5
subsd  %xmm4,%xmm5
mulsd  0xb43(%rip),%xmm5
movapd %xmm5,%xmm1
mulsd  %xmm5,%xmm1
movapd %xmm2,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
ucomisd %xmm11,%xmm0
mov    %rsi,0x20(%rsp)
mov    %r10,0x18(%rsp)
mov    %rdi,0x10(%rsp)
movapd %xmm2,0x80(%rsp)
movsd  %xmm3,0xb0(%rsp)
movsd  %xmm4,0xa8(%rsp)
jb     1510 <cvJacobiEigens_64d+0x3f0>
sqrtsd %xmm0,%xmm0
jmp    152f <cvJacobiEigens_64d+0x40f>
movapd %xmm5,0x40(%rsp)
call   1040 <sqrt@plt>
movapd 0x40(%rsp),%xmm5
movapd 0x80(%rsp),%xmm2
xorpd  %xmm11,%xmm11
movapd %xmm2,%xmm3
movapd 0xaf5(%rip),%xmm1
xorpd  %xmm1,%xmm3
divsd  %xmm0,%xmm3
cmpltsd %xmm11,%xmm5
movapd %xmm5,%xmm0
andnpd %xmm3,%xmm0
xorpd  %xmm1,%xmm3
andpd  %xmm5,%xmm3
orpd   %xmm0,%xmm3
movapd %xmm3,%xmm1
mulsd  %xmm3,%xmm1
movsd  0xaa3(%rip),%xmm0
subsd  %xmm1,%xmm0
ucomisd %xmm11,%xmm0
movapd %xmm3,0x40(%rsp)
jb     1590 <cvJacobiEigens_64d+0x470>
sqrtsd %xmm0,%xmm0
jmp    159a <cvJacobiEigens_64d+0x47a>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
call   1040 <sqrt@plt>
xorpd  %xmm11,%xmm11
addsd  0xa6e(%rip),%xmm0
addsd  %xmm0,%xmm0
ucomisd %xmm11,%xmm0
jb     15c0 <cvJacobiEigens_64d+0x4a0>
sqrtsd %xmm0,%xmm0
jmp    15ca <cvJacobiEigens_64d+0x4aa>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
call   1040 <sqrt@plt>
xorpd  %xmm11,%xmm11
movapd 0x40(%rsp),%xmm15
divsd  %xmm0,%xmm15
movapd %xmm15,%xmm7
mulsd  %xmm15,%xmm7
movsd  0xa28(%rip),%xmm0
subsd  %xmm7,%xmm0
ucomisd %xmm11,%xmm0
jb     1600 <cvJacobiEigens_64d+0x4e0>
sqrtsd %xmm0,%xmm0
jmp    1624 <cvJacobiEigens_64d+0x504>
nopl   0x0(%rax)
movapd %xmm15,0x40(%rsp)
movapd %xmm7,0x70(%rsp)
call   1040 <sqrt@plt>
movapd 0x70(%rsp),%xmm7
movapd 0x40(%rsp),%xmm15
xorpd  %xmm11,%xmm11
mov    0x38(%rsp),%rcx
movsd  0xa0(%rsp),%xmm9
movapd 0x9e4(%rip),%xmm10
mov    0x20(%rsp),%rsi
mov    0x18(%rsp),%r10
mov    0x10(%rsp),%rdi
movapd 0x80(%rsp),%xmm12
movsd  0xb0(%rsp),%xmm13
movsd  0xa8(%rsp),%xmm14
test   %r12,%r12
je     1703 <cvJacobiEigens_64d+0x5e3>
mov    0x8(%rsp),%rax
xor    %edx,%edx
nopl   0x0(%rax)
movsd  (%rax,%r12,8),%xmm1
movsd  (%rax,%rdi,1),%xmm2
movsd  0x0(%rbp,%rdx,8),%xmm3
movsd  (%r14,%rdx,8),%xmm4
movapd %xmm15,%xmm5
mulsd  %xmm2,%xmm5
movapd %xmm15,%xmm6
mulsd  %xmm1,%xmm6
mulsd  %xmm0,%xmm1
subsd  %xmm5,%xmm1
movsd  %xmm1,(%rax,%r12,8)
mulsd  %xmm0,%xmm2
addsd  %xmm6,%xmm2
movsd  %xmm2,(%rax,%rdi,1)
movapd %xmm15,%xmm1
mulsd  %xmm4,%xmm1
movapd %xmm15,%xmm2
mulsd  %xmm3,%xmm2
mulsd  %xmm0,%xmm3
subsd  %xmm1,%xmm3
movsd  %xmm3,0x0(%rbp,%rdx,8)
mulsd  %xmm0,%xmm4
addsd  %xmm2,%xmm4
movsd  %xmm4,(%r14,%rdx,8)
add    $0x1,%rdx
add    %r13,%rax
cmp    %rdx,%r12
jne    1680 <cvJacobiEigens_64d+0x560>
mov    %r12d,%r8d
jmp    170b <cvJacobiEigens_64d+0x5eb>
xor    %r8d,%r8d
mov    0x8(%rsp),%rax
mov    %r8d,%edx
cmp    %rdx,%rbx
jbe    179f <cvJacobiEigens_64d+0x67f>
lea    (%rax,%rbx,8),%rax
nopl   0x0(%rax,%rax,1)
movsd  (%r15,%rdx,8),%xmm1
movsd  (%rax),%xmm2
movsd  0x0(%rbp,%rdx,8),%xmm3
movsd  (%r14,%rdx,8),%xmm4
movapd %xmm15,%xmm5
mulsd  %xmm2,%xmm5
movapd %xmm15,%xmm6
mulsd  %xmm1,%xmm6
mulsd  %xmm0,%xmm1
subsd  %xmm5,%xmm1
movsd  %xmm1,(%r15,%rdx,8)
mulsd  %xmm0,%xmm2
addsd  %xmm6,%xmm2
movsd  %xmm2,(%rax)
movapd %xmm15,%xmm1
mulsd  %xmm4,%xmm1
movapd %xmm15,%xmm2
mulsd  %xmm3,%xmm2
mulsd  %xmm0,%xmm3
subsd  %xmm1,%xmm3
movsd  %xmm3,0x0(%rbp,%rdx,8)
mulsd  %xmm0,%xmm4
addsd  %xmm2,%xmm4
movsd  %xmm4,(%r14,%rdx,8)
add    $0x1,%rdx
add    %r13,%rax
cmp    %rdx,%rbx
jne    1720 <cvJacobiEigens_64d+0x600>
mov    %ebx,%r8d
cmp    %ecx,%r8d
jge    1410 <cvJacobiEigens_64d+0x2f0>
mov    %r8d,%eax
not    %r8d
add    %ecx,%r8d
je     19c0 <cvJacobiEigens_64d+0x8a0>
mov    %rbx,0x28(%rsp)
mov    %r10,%rcx
imul   0x98(%rsp),%rcx
add    0xe8(%rsp),%rcx
mov    0x8(%rsp),%rdx
lea    (%rdx,%rcx,8),%rdi
mov    0x60(%rsp),%rdx
lea    (%rdx,%rcx,8),%r13
lea    (%r15,%rax,8),%rdx
lea    (%r8,%rax,1),%rbx
mov    0xf0(%rsp),%rcx
lea    (%rcx,%rbx,8),%r10
lea    (%rsi,%rax,8),%rsi
lea    (%rdi,%rbx,8),%r9
lea    0x0(%rbp,%rax,8),%rdi
mov    0xe0(%rsp),%rcx
lea    (%rcx,%rbx,8),%rcx
lea    (%r14,%rax,8),%r11
lea    0x0(,%rbx,8),%rbx
add    %r13,%rbx
cmp    %r9,%rdx
setb   0x40(%rsp)
cmp    %r10,%rsi
setb   0x70(%rsp)
cmp    %rcx,%rdx
setb   %r13b
cmp    %r10,%rdi
setb   0x7(%rsp)
cmp    %rbx,%rdx
setb   0x6(%rsp)
cmp    %r10,%r11
setb   0x5(%rsp)
cmp    %rcx,%rsi
setb   %r10b
cmp    %r9,%rdi
setb   0x4(%rsp)
cmp    %rbx,%rsi
setb   0x3(%rsp)
cmp    %r9,%r11
setb   0x2(%rsp)
cmp    %rbx,%rdi
setb   %r9b
cmp    %rcx,%r11
setb   %bl
mov    0x70(%rsp),%cl
test   %cl,0x40(%rsp)
jne    19a0 <cvJacobiEigens_64d+0x880>
and    0x7(%rsp),%r13b
mov    0x38(%rsp),%rcx
mov    0x68(%rsp),%r13
jne    19aa <cvJacobiEigens_64d+0x88a>
mov    %bl,0x40(%rsp)
mov    0x5(%rsp),%bl
and    %bl,0x6(%rsp)
jne    19aa <cvJacobiEigens_64d+0x88a>
and    0x4(%rsp),%r10b
jne    19aa <cvJacobiEigens_64d+0x88a>
mov    0x2(%rsp),%bl
and    %bl,0x3(%rsp)
jne    19aa <cvJacobiEigens_64d+0x88a>
and    0x40(%rsp),%r9b
jne    19aa <cvJacobiEigens_64d+0x88a>
movapd %xmm7,0x70(%rsp)
add    $0x1,%r8
mov    %r8,%r9
and    $0xfffffffffffffffe,%r9
add    %r9,%rax
movapd %xmm15,%xmm8
unpcklpd %xmm15,%xmm8
movapd %xmm0,%xmm2
unpcklpd %xmm0,%xmm2
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movupd (%rdx,%rbx,8),%xmm3
movupd (%rsi,%rbx,8),%xmm4
movupd (%rdi,%rbx,8),%xmm5
movupd (%r11,%rbx,8),%xmm6
movapd %xmm8,%xmm7
mulpd  %xmm4,%xmm7
movapd %xmm8,%xmm1
mulpd  %xmm3,%xmm1
mulpd  %xmm2,%xmm3
subpd  %xmm7,%xmm3
movupd %xmm3,(%rdx,%rbx,8)
mulpd  %xmm2,%xmm4
addpd  %xmm1,%xmm4
movupd %xmm4,(%rsi,%rbx,8)
movapd %xmm8,%xmm1
mulpd  %xmm6,%xmm1
movapd %xmm8,%xmm3
mulpd  %xmm5,%xmm3
mulpd  %xmm2,%xmm5
subpd  %xmm1,%xmm5
movupd %xmm5,(%rdi,%rbx,8)
mulpd  %xmm2,%xmm6
addpd  %xmm3,%xmm6
movupd %xmm6,(%r11,%rbx,8)
add    $0x2,%rbx
cmp    %rbx,%r9
jne    1900 <cvJacobiEigens_64d+0x7e0>
cmp    %r9,%r8
mov    0x68(%rsp),%r13
mov    0x20(%rsp),%rsi
mov    0x18(%rsp),%r10
mov    0x28(%rsp),%rbx
mov    0x10(%rsp),%rdi
movapd 0x70(%rsp),%xmm7
jne    19c0 <cvJacobiEigens_64d+0x8a0>
jmp    1410 <cvJacobiEigens_64d+0x2f0>
mov    0x38(%rsp),%rcx
mov    0x68(%rsp),%r13
mov    0x20(%rsp),%rsi
mov    0x18(%rsp),%r10
mov    0x28(%rsp),%rbx
mov    0x10(%rsp),%rdi
xchg   %ax,%ax
movsd  (%r15,%rax,8),%xmm1
movsd  (%rsi,%rax,8),%xmm2
movsd  0x0(%rbp,%rax,8),%xmm3
movsd  (%r14,%rax,8),%xmm4
movapd %xmm15,%xmm5
mulsd  %xmm2,%xmm5
movapd %xmm15,%xmm6
mulsd  %xmm1,%xmm6
mulsd  %xmm0,%xmm1
subsd  %xmm5,%xmm1
movsd  %xmm1,(%r15,%rax,8)
mulsd  %xmm0,%xmm2
addsd  %xmm6,%xmm2
movsd  %xmm2,(%rsi,%rax,8)
movapd %xmm15,%xmm1
mulsd  %xmm4,%xmm1
movapd %xmm15,%xmm2
mulsd  %xmm3,%xmm2
mulsd  %xmm0,%xmm3
subsd  %xmm1,%xmm3
movsd  %xmm3,0x0(%rbp,%rax,8)
mulsd  %xmm0,%xmm4
addsd  %xmm2,%xmm4
movsd  %xmm4,(%r14,%rax,8)
add    $0x1,%rax
cmp    %ecx,%eax
jl     19c0 <cvJacobiEigens_64d+0x8a0>
jmp    1410 <cvJacobiEigens_64d+0x2f0>
nop
mov    0x98(%rsp),%r8
lea    (%r15,%r8,8),%r15
lea    0x0(%rbp,%r8,8),%rbp
mov    0xd8(%rsp),%rbx
add    $0x1,%rbx
mov    0xd0(%rsp),%rsi
mov    %rsi,%r12
cmp    0xc8(%rsp),%rsi
jne    1380 <cvJacobiEigens_64d+0x260>
cmp    $0x2,%ecx
jl     1340 <cvJacobiEigens_64d+0x220>
xor    %r12d,%r12d
mov    $0x1,%ebx
mov    0x8(%rsp),%r15
mov    0x60(%rsp),%rbp
test   %r9d,%r9d
mov    $0x0,%r9d
jne    1380 <cvJacobiEigens_64d+0x260>
jmp    1340 <cvJacobiEigens_64d+0x220>
test   %ecx,%ecx
mov    0xb8(%rsp),%rbx
jle    1c38 <cvJacobiEigens_64d+0xb18>
lea    0x1(%rcx),%eax
movslq %eax,%r10
cmp    $0x4,%ecx
jae    1ace <cvJacobiEigens_64d+0x9ae>
xor    %ecx,%ecx
xor    %edx,%edx
mov    0x30(%rsp),%rdi
jmp    1b8e <cvJacobiEigens_64d+0xa6e>
mov    0x30(%rsp),%rdi
lea    -0x1(%rdi),%rcx
imul   %r10,%rcx
mov    0x8(%rsp),%rax
lea    (%rax,%rcx,8),%rdx
cmp    %rax,%rdx
mov    %rdx,%rcx
cmova  %rax,%rcx
cmovb  %rax,%rdx
add    $0x8,%rdx
cmp    %rbx,%rdx
jbe    1b0d <cvJacobiEigens_64d+0x9ed>
lea    (%rbx,%rdi,8),%rdx
cmp    %rdx,%rcx
jae    1b0d <cvJacobiEigens_64d+0x9ed>
xor    %ecx,%ecx
xor    %edx,%edx
jmp    1b8e <cvJacobiEigens_64d+0xa6e>
mov    %edi,%edx
and    $0xfffffffc,%edx
mov    %rdx,%rcx
imul   %r10,%rcx
lea    0x0(,%rdi,8),%r8
and    $0xffffffffffffffe0,%r8
mov    %r10,%rdi
shl    $0x5,%rdi
lea    0x0(,%r10,8),%rsi
lea    (%rsi,%rsi,2),%r9
mov    %r10,%rax
shl    $0x4,%rax
xor    %esi,%esi
mov    0x8(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
movsd  0x0(%rbp),%xmm0
movhpd 0x0(%rbp,%r10,8),%xmm0
movsd  0x0(%rbp,%rax,1),%xmm1
movhpd 0x0(%rbp,%r9,1),%xmm1
movupd %xmm0,(%rbx,%rsi,1)
movupd %xmm1,0x10(%rbx,%rsi,1)
add    $0x20,%rsi
add    %rdi,%rbp
cmp    %rsi,%r8
jne    1b50 <cvJacobiEigens_64d+0xa30>
mov    0x30(%rsp),%rdi
cmp    %rdi,%rdx
je     1c38 <cvJacobiEigens_64d+0xb18>
mov    %rdx,%rax
not    %rax
add    %rdi,%rax
and    $0x3,%rdi
je     1bc9 <cvJacobiEigens_64d+0xaa9>
mov    0x8(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rsi,%rcx,8),%xmm0
movsd  %xmm0,(%rbx,%rdx,8)
add    $0x1,%rdx
add    %r10,%rcx
add    $0xffffffffffffffff,%rdi
jne    1bb0 <cvJacobiEigens_64d+0xa90>
jmp    1bce <cvJacobiEigens_64d+0xaae>
mov    0x8(%rsp),%rsi
cmp    $0x3,%rax
mov    0x30(%rsp),%r9
jb     1c38 <cvJacobiEigens_64d+0xb18>
lea    0x0(,%rcx,8),%r8
mov    %r10,%rdi
shl    $0x5,%rdi
lea    (%r10,%r10,2),%rbp
lea    (%r8,%rbp,8),%rbp
mov    %r10,%rax
shl    $0x4,%rax
lea    (%rax,%rcx,8),%rax
add    %r10,%rcx
xchg   %ax,%ax
movsd  (%rsi,%r8,1),%xmm0
movsd  %xmm0,(%rbx,%rdx,8)
movsd  (%rsi,%rcx,8),%xmm0
movsd  %xmm0,0x8(%rbx,%rdx,8)
movsd  (%rsi,%rax,1),%xmm0
movsd  %xmm0,0x10(%rbx,%rdx,8)
movsd  (%rsi,%rbp,1),%xmm0
movsd  %xmm0,0x18(%rbx,%rdx,8)
add    $0x4,%rdx
add    %rdi,%rsi
cmp    %rdx,%r9
jne    1c00 <cvJacobiEigens_64d+0xae0>
xor    %eax,%eax
add    $0xf8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define i32 @cvJacobiEigens_64d(double* nocapture %0, double* nocapture %1, double* nocapture writeonly %2, i32 %3, double %4) {
%6 = fcmp olt double %4, 1.000000e-15
%7 = select i1 %6, double 1.000000e-15, double %4
%8 = sitofp i32 %3 to double
%9 = icmp sgt i32 %3, 0
br i1 %9, label %10, label %71
10: ; preds = %5
%11 = zext i32 %3 to i64
%12 = zext i32 %3 to i64
%13 = shl nuw nsw i64 %12, 3
br label %14
14: ; preds = %10, %64
%15 = phi i64 [ 0, %10 ], [ %67, %64 ]
%16 = phi double* [ %0, %10 ], [ %69, %64 ]
%17 = phi double* [ %1, %10 ], [ %68, %64 ]
%18 = phi double [ 0.000000e+00, %10 ], [ %65, %64 ]
%19 = bitcast double* %17 to i8*
%20 = icmp eq i64 %15, 0
br i1 %20, label %64, label %21
21: ; preds = %14
%22 = add nsw i64 %15, -1
%23 = and i64 %15, 3
%24 = icmp ult i64 %22, 3
br i1 %24, label %49, label %25
25: ; preds = %21
%26 = and i64 %15, 9223372036854775804
br label %27
27: ; preds = %27, %25
%28 = phi i64 [ 0, %25 ], [ %46, %27 ]
%29 = phi double [ %18, %25 ], [ %45, %27 ]
%30 = phi i64 [ 0, %25 ], [ %47, %27 ]
%31 = getelementptr inbounds double, double* %16, i64 %28
%32 = load double, double* %31
%33 = tail call double @llvm.fmuladd.f64(double %32, double %32, double %29)
%34 = or i64 %28, 1
%35 = getelementptr inbounds double, double* %16, i64 %34
%36 = load double, double* %35
%37 = tail call double @llvm.fmuladd.f64(double %36, double %36, double %33)
%38 = or i64 %28, 2
%39 = getelementptr inbounds double, double* %16, i64 %38
%40 = load double, double* %39
%41 = tail call double @llvm.fmuladd.f64(double %40, double %40, double %37)
%42 = or i64 %28, 3
%43 = getelementptr inbounds double, double* %16, i64 %42
%44 = load double, double* %43
%45 = tail call double @llvm.fmuladd.f64(double %44, double %44, double %41)
%46 = add nuw nsw i64 %28, 4
%47 = add i64 %30, 4
%48 = icmp eq i64 %47, %26
br i1 %48, label %49, label %27
49: ; preds = %27, %21
%50 = phi double [ undef, %21 ], [ %45, %27 ]
%51 = phi i64 [ 0, %21 ], [ %46, %27 ]
%52 = phi double [ %18, %21 ], [ %45, %27 ]
%53 = icmp eq i64 %23, 0
br i1 %53, label %64, label %54
54: ; preds = %49, %54
%55 = phi i64 [ %61, %54 ], [ %51, %49 ]
%56 = phi double [ %60, %54 ], [ %52, %49 ]
%57 = phi i64 [ %62, %54 ], [ 0, %49 ]
%58 = getelementptr inbounds double, double* %16, i64 %55
%59 = load double, double* %58
%60 = tail call double @llvm.fmuladd.f64(double %59, double %59, double %56)
%61 = add nuw nsw i64 %55, 1
%62 = add i64 %57, 1
%63 = icmp eq i64 %62, %23
br i1 %63, label %64, label %54
64: ; preds = %49, %54, %14
%65 = phi double [ %18, %14 ], [ %50, %49 ], [ %60, %54 ]
%66 = getelementptr inbounds double, double* %17, i64 %15
store double 1.000000e+00, double* %66
%67 = add nuw nsw i64 %15, 1
%68 = getelementptr inbounds double, double* %17, i64 %11
%69 = getelementptr inbounds double, double* %16, i64 %11
%70 = icmp eq i64 %67, %12
br i1 %70, label %71, label %14
71: ; preds = %64, %5
%72 = phi double [ 0.000000e+00, %5 ], [ %65, %64 ]
%73 = fadd double %72, %72
%74 = tail call double @sqrt(double %73)
%75 = fmul double %7, %74
%76 = fdiv double %75, %8
%77 = fcmp ogt double %74, %76
br i1 %77, label %78, label %87
78: ; preds = %71
%79 = add i32 %3, -1
%80 = icmp sgt i32 %3, 1
%81 = sext i32 %3 to i64
%82 = zext i32 %79 to i64
%83 = zext i32 %3 to i64
%84 = add nsw i64 %81, 1
br label %159
85: ; preds = %417, %159
%86 = fcmp ogt double %161, %76
br i1 %86, label %159, label %87
87: ; preds = %85, %71
br i1 %9, label %88, label %444
88: ; preds = %87
%89 = add nuw i32 %3, 1
%90 = sext i32 %89 to i64
%91 = zext i32 %3 to i64
%92 = icmp ult i32 %3, 4
br i1 %92, label %137, label %93
93: ; preds = %88
%94 = getelementptr double, double* %2, i64 %91
%95 = add nsw i64 %91, -1
%96 = mul i64 %95, %90
%97 = getelementptr double, double* %0, i64 %96
%98 = icmp ugt double* %97, %0
%99 = select i1 %98, double* %0, double* %97
%100 = icmp ult double* %97, %0
%101 = select i1 %100, double* %0, double* %97
%102 = getelementptr double, double* %101, i64 1
%103 = icmp ugt double* %102, %2
%104 = icmp ult double* %99, %94
%105 = and i1 %103, %104
br i1 %105, label %137, label %106
106: ; preds = %93
%107 = and i64 %91, 4294967292
%108 = mul nsw i64 %107, %90
%109 = shl nsw i64 %90, 1
%110 = mul nsw i64 %90, 3
br label %111
111: ; preds = %111, %106
%112 = phi i64 [ 0, %106 ], [ %133, %111 ]
%113 = mul i64 %112, %90
%114 = add i64 %113, %90
%115 = add i64 %113, %109
%116 = add i64 %113, %110
%117 = getelementptr inbounds double, double* %0, i64 %113
%118 = getelementptr inbounds double, double* %0, i64 %114
%119 = getelementptr inbounds double, double* %0, i64 %115
%120 = getelementptr inbounds double, double* %0, i64 %116
%121 = load double, double* %117
%122 = load double, double* %118
%123 = insertelement <2 x double> poison, double %121, i64 0
%124 = insertelement <2 x double> %123, double %122, i64 1
%125 = load double, double* %119
%126 = load double, double* %120
%127 = insertelement <2 x double> poison, double %125, i64 0
%128 = insertelement <2 x double> %127, double %126, i64 1
%129 = getelementptr inbounds double, double* %2, i64 %112
%130 = bitcast double* %129 to <2 x double>*
store <2 x double> %124, <2 x double>* %130
%131 = getelementptr inbounds double, double* %129, i64 2
%132 = bitcast double* %131 to <2 x double>*
store <2 x double> %128, <2 x double>* %132
%133 = add nuw i64 %112, 4
%134 = icmp eq i64 %133, %107
br i1 %134, label %135, label %111
135: ; preds = %111
%136 = icmp eq i64 %107, %91
br i1 %136, label %444, label %137
137: ; preds = %93, %88, %135
%138 = phi i64 [ 0, %93 ], [ 0, %88 ], [ %108, %135 ]
%139 = phi i64 [ 0, %93 ], [ 0, %88 ], [ %107, %135 ]
%140 = xor i64 %139, -1
%141 = add nsw i64 %140, %91
%142 = and i64 %91, 3
%143 = icmp eq i64 %142, 0
br i1 %143, label %155, label %144
144: ; preds = %137, %144
%145 = phi i64 [ %152, %144 ], [ %138, %137 ]
%146 = phi i64 [ %151, %144 ], [ %139, %137 ]
%147 = phi i64 [ %153, %144 ], [ 0, %137 ]
%148 = getelementptr inbounds double, double* %0, i64 %145
%149 = load double, double* %148
%150 = getelementptr inbounds double, double* %2, i64 %146
store double %149, double* %150
%151 = add nuw nsw i64 %146, 1
%152 = add nsw i64 %145, %90
%153 = add i64 %147, 1
%154 = icmp eq i64 %153, %142
br i1 %154, label %155, label %144
155: ; preds = %144, %137
%156 = phi i64 [ %138, %137 ], [ %152, %144 ]
%157 = phi i64 [ %139, %137 ], [ %151, %144 ]
%158 = icmp ult i64 %141, 3
br i1 %158, label %444, label %420
159: ; preds = %78, %85
%160 = phi double [ %74, %78 ], [ %161, %85 ]
%161 = fdiv double %160, %8
br i1 %80, label %162, label %85
162: ; preds = %159, %411
%163 = phi i64 [ %412, %411 ], [ 0, %159 ]
%164 = phi i64 [ %413, %411 ], [ 1, %159 ]
%165 = phi i32 [ %414, %411 ], [ 0, %159 ]
%166 = phi double* [ %415, %411 ], [ %0, %159 ]
%167 = phi double* [ %416, %411 ], [ %1, %159 ]
%168 = mul i64 %163, %81
%169 = add i64 %168, 1
%170 = getelementptr double, double* %0, i64 %169
%171 = add i64 %84, %168
%172 = getelementptr double, double* %1, i64 %169
%173 = add nuw nsw i64 %163, 1
%174 = mul nsw i64 %173, %81
%175 = icmp slt i64 %173, %81
br i1 %175, label %176, label %405
176: ; preds = %162
%177 = getelementptr inbounds double, double* %1, i64 %174
%178 = getelementptr inbounds double, double* %0, i64 %174
%179 = getelementptr inbounds double, double* %166, i64 %163
%180 = icmp eq i64 %163, 0
%181 = trunc i64 %163 to i32
br label %182
182: ; preds = %176, %398
%183 = phi i64 [ 0, %176 ], [ %404, %398 ]
%184 = phi i64 [ %164, %176 ], [ %400, %398 ]
%185 = phi i32 [ %165, %176 ], [ %399, %398 ]
%186 = phi double* [ %178, %176 ], [ %401, %398 ]
%187 = phi double* [ %177, %176 ], [ %402, %398 ]
%188 = mul i64 %183, %81
%189 = add i64 %171, %188
%190 = getelementptr double, double* %0, i64 %189
%191 = getelementptr double, double* %1, i64 %189
%192 = getelementptr inbounds double, double* %166, i64 %184
%193 = load double, double* %192
%194 = tail call double @llvm.fabs.f64(double %193)
%195 = fcmp olt double %194, %161
br i1 %195, label %398, label %196
196: ; preds = %182
%197 = load double, double* %179
%198 = getelementptr inbounds double, double* %186, i64 %184
%199 = load double, double* %198
%200 = fsub double %197, %199
%201 = fmul double %200, 5.000000e-01
%202 = fneg double %193
%203 = fmul double %201, %201
%204 = tail call double @llvm.fmuladd.f64(double %193, double %193, double %203)
%205 = tail call double @sqrt(double %204)
%206 = fdiv double %202, %205
%207 = fcmp olt double %201, 0.000000e+00
%208 = fneg double %206
%209 = select i1 %207, double %208, double %206
%210 = fneg double %209
%211 = tail call double @llvm.fmuladd.f64(double %210, double %209, double 1.000000e+00)
%212 = tail call double @sqrt(double %211)
%213 = fadd double %212, 1.000000e+00
%214 = fmul double %213, 2.000000e+00
%215 = tail call double @sqrt(double %214)
%216 = fdiv double %209, %215
%217 = fmul double %216, %216
%218 = fsub double 1.000000e+00, %217
%219 = tail call double @sqrt(double %218)
%220 = fmul double %219, %219
%221 = fmul double %193, 2.000000e+00
%222 = fmul double %221, %219
%223 = fmul double %222, %216
br i1 %180, label %224, label %229
224: ; preds = %229, %196
%225 = phi double* [ %0, %196 ], [ %251, %229 ]
%226 = phi i32 [ 0, %196 ], [ %181, %229 ]
%227 = zext i32 %226 to i64
%228 = icmp ugt i64 %184, %227
br i1 %228, label %343, label %255
229: ; preds = %196, %229
%230 = phi i64 [ %250, %229 ], [ 0, %196 ]
%231 = phi double* [ %251, %229 ], [ %0, %196 ]
%232 = getelementptr inbounds double, double* %231, i64 %163
%233 = load double, double* %232
%234 = getelementptr inbounds double, double* %231, i64 %184
%235 = load double, double* %234
%236 = getelementptr inbounds double, double* %167, i64 %230
%237 = load double, double* %236
%238 = getelementptr inbounds double, double* %187, i64 %230
%239 = load double, double* %238
%240 = fneg double %235
%241 = fmul double %216, %240
%242 = tail call double @llvm.fmuladd.f64(double %233, double %219, double %241)
store double %242, double* %232
%243 = fmul double %216, %233
%244 = tail call double @llvm.fmuladd.f64(double %235, double %219, double %243)
store double %244, double* %234
%245 = fneg double %239
%246 = fmul double %216, %245
%247 = tail call double @llvm.fmuladd.f64(double %237, double %219, double %246)
store double %247, double* %236
%248 = fmul double %216, %237
%249 = tail call double @llvm.fmuladd.f64(double %239, double %219, double %248)
store double %249, double* %238
%250 = add nuw nsw i64 %230, 1
%251 = getelementptr inbounds double, double* %231, i64 %81
%252 = icmp eq i64 %250, %163
br i1 %252, label %224, label %229
253: ; preds = %343
%254 = trunc i64 %184 to i32
br label %255
255: ; preds = %253, %224
%256 = phi i32 [ %226, %224 ], [ %254, %253 ]
%257 = icmp slt i32 %256, %3
br i1 %257, label %258, label %390
258: ; preds = %255
%259 = zext i32 %256 to i64
%260 = xor i32 %256, -1
%261 = add i32 %260, %3
%262 = zext i32 %261 to i64
%263 = add nuw nsw i64 %262, 1
%264 = icmp eq i32 %261, 0
br i1 %264, label %341, label %265
265: ; preds = %258
%266 = getelementptr double, double* %166, i64 %259
%267 = xor i32 %256, -1
%268 = add i32 %267, %3
%269 = zext i32 %268 to i64
%270 = add nuw nsw i64 %259, %269
%271 = getelementptr double, double* %170, i64 %270
%272 = getelementptr double, double* %186, i64 %259
%273 = getelementptr double, double* %190, i64 %270
%274 = getelementptr double, double* %167, i64 %259
%275 = getelementptr double, double* %172, i64 %270
%276 = getelementptr double, double* %187, i64 %259
%277 = getelementptr double, double* %191, i64 %270
%278 = icmp ult double* %266, %273
%279 = icmp ult double* %272, %271
%280 = and i1 %278, %279
%281 = icmp ult double* %266, %275
%282 = icmp ult double* %274, %271
%283 = and i1 %281, %282
%284 = or i1 %280, %283
%285 = icmp ult double* %266, %277
%286 = icmp ult double* %276, %271
%287 = and i1 %285, %286
%288 = or i1 %284, %287
%289 = icmp ult double* %272, %275
%290 = icmp ult double* %274, %273
%291 = and i1 %289, %290
%292 = or i1 %288, %291
%293 = icmp ult double* %272, %277
%294 = icmp ult double* %276, %273
%295 = and i1 %293, %294
%296 = or i1 %292, %295
%297 = icmp ult double* %274, %277
%298 = icmp ult double* %276, %275
%299 = and i1 %297, %298
%300 = or i1 %296, %299
br i1 %300, label %341, label %301
301: ; preds = %265
%302 = and i64 %263, 8589934590
%303 = add nuw nsw i64 %302, %259
%304 = insertelement <2 x double> poison, double %216, i64 0
%305 = shufflevector <2 x double> %304, <2 x double> poison, <2 x i32> zeroinitializer
%306 = insertelement <2 x double> poison, double %219, i64 0
%307 = shufflevector <2 x double> %306, <2 x double> poison, <2 x i32> zeroinitializer
br label %308
308: ; preds = %308, %301
%309 = phi i64 [ 0, %301 ], [ %337, %308 ]
%310 = add i64 %309, %259
%311 = getelementptr inbounds double, double* %166, i64 %310
%312 = bitcast double* %311 to <2 x double>*
%313 = load <2 x double>, <2 x double>* %312
%314 = getelementptr inbounds double, double* %186, i64 %310
%315 = bitcast double* %314 to <2 x double>*
%316 = load <2 x double>, <2 x double>* %315
%317 = getelementptr inbounds double, double* %167, i64 %310
%318 = bitcast double* %317 to <2 x double>*
%319 = load <2 x double>, <2 x double>* %318
%320 = getelementptr inbounds double, double* %187, i64 %310
%321 = bitcast double* %320 to <2 x double>*
%322 = load <2 x double>, <2 x double>* %321
%323 = fneg <2 x double> %316
%324 = fmul <2 x double> %305, %323
%325 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %313, <2 x double> %307, <2 x double> %324)
%326 = bitcast double* %311 to <2 x double>*
store <2 x double> %325, <2 x double>* %326
%327 = fmul <2 x double> %305, %313
%328 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %316, <2 x double> %307, <2 x double> %327)
%329 = bitcast double* %314 to <2 x double>*
store <2 x double> %328, <2 x double>* %329
%330 = fneg <2 x double> %322
%331 = fmul <2 x double> %305, %330
%332 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %319, <2 x double> %307, <2 x double> %331)
%333 = bitcast double* %317 to <2 x double>*
store <2 x double> %332, <2 x double>* %333
%334 = fmul <2 x double> %305, %319
%335 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %322, <2 x double> %307, <2 x double> %334)
%336 = bitcast double* %320 to <2 x double>*
store <2 x double> %335, <2 x double>* %336
%337 = add nuw i64 %309, 2
%338 = icmp eq i64 %337, %302
br i1 %338, label %339, label %308
339: ; preds = %308
%340 = icmp eq i64 %263, %302
br i1 %340, label %390, label %341
341: ; preds = %265, %258, %339
%342 = phi i64 [ %259, %265 ], [ %259, %258 ], [ %303, %339 ]
br label %367
343: ; preds = %224, %343
%344 = phi i64 [ %364, %343 ], [ %227, %224 ]
%345 = phi double* [ %365, %343 ], [ %225, %224 ]
%346 = getelementptr inbounds double, double* %166, i64 %344
%347 = load double, double* %346
%348 = getelementptr inbounds double, double* %345, i64 %184
%349 = load double, double* %348
%350 = getelementptr inbounds double, double* %167, i64 %344
%351 = load double, double* %350
%352 = getelementptr inbounds double, double* %187, i64 %344
%353 = load double, double* %352
%354 = fneg double %349
%355 = fmul double %216, %354
%356 = tail call double @llvm.fmuladd.f64(double %347, double %219, double %355)
store double %356, double* %346
%357 = fmul double %216, %347
%358 = tail call double @llvm.fmuladd.f64(double %349, double %219, double %357)
store double %358, double* %348
%359 = fneg double %353
%360 = fmul double %216, %359
%361 = tail call double @llvm.fmuladd.f64(double %351, double %219, double %360)
store double %361, double* %350
%362 = fmul double %216, %351
%363 = tail call double @llvm.fmuladd.f64(double %353, double %219, double %362)
store double %363, double* %352
%364 = add nuw nsw i64 %344, 1
%365 = getelementptr inbounds double, double* %345, i64 %81
%366 = icmp eq i64 %364, %184
br i1 %366, label %253, label %343
367: ; preds = %341, %367
%368 = phi i64 [ %387, %367 ], [ %342, %341 ]
%369 = getelementptr inbounds double, double* %166, i64 %368
%370 = load double, double* %369
%371 = getelementptr inbounds double, double* %186, i64 %368
%372 = load double, double* %371
%373 = getelementptr inbounds double, double* %167, i64 %368
%374 = load double, double* %373
%375 = getelementptr inbounds double, double* %187, i64 %368
%376 = load double, double* %375
%377 = fneg double %372
%378 = fmul double %216, %377
%379 = tail call double @llvm.fmuladd.f64(double %370, double %219, double %378)
store double %379, double* %369
%380 = fmul double %216, %370
%381 = tail call double @llvm.fmuladd.f64(double %372, double %219, double %380)
store double %381, double* %371
%382 = fneg double %376
%383 = fmul double %216, %382
%384 = tail call double @llvm.fmuladd.f64(double %374, double %219, double %383)
store double %384, double* %373
%385 = fmul double %216, %374
%386 = tail call double @llvm.fmuladd.f64(double %376, double %219, double %385)
store double %386, double* %375
%387 = add nuw nsw i64 %368, 1
%388 = trunc i64 %387 to i32
%389 = icmp slt i32 %388, %3
br i1 %389, label %367, label %390
390: ; preds = %367, %339, %255
%391 = fmul double %199, %217
%392 = tail call double @llvm.fmuladd.f64(double %197, double %220, double %391)
%393 = fsub double %392, %223
%394 = fmul double %199, %220
%395 = tail call double @llvm.fmuladd.f64(double %197, double %217, double %394)
%396 = fadd double %223, %395
store double %393, double* %179
store double %396, double* %198
%397 = getelementptr inbounds double, double* %186, i64 %163
store double 0.000000e+00, double* %397
store double 0.000000e+00, double* %192
br label %398
398: ; preds = %182, %390
%399 = phi i32 [ 1, %390 ], [ %185, %182 ]
%400 = add nuw nsw i64 %184, 1
%401 = getelementptr inbounds double, double* %186, i64 %81
%402 = getelementptr inbounds double, double* %187, i64 %81
%403 = icmp eq i64 %400, %83
%404 = add i64 %183, 1
br i1 %403, label %405, label %182
405: ; preds = %398, %162
%406 = phi i32 [ %165, %162 ], [ %399, %398 ]
%407 = getelementptr inbounds double, double* %166, i64 %81
%408 = getelementptr inbounds double, double* %167, i64 %81
%409 = add nuw nsw i64 %164, 1
%410 = icmp eq i64 %173, %82
br i1 %410, label %417, label %411
411: ; preds = %405, %417
%412 = phi i64 [ %173, %405 ], [ 0, %417 ]
%413 = phi i64 [ %409, %405 ], [ 1, %417 ]
%414 = phi i32 [ %406, %405 ], [ 0, %417 ]
%415 = phi double* [ %407, %405 ], [ %0, %417 ]
%416 = phi double* [ %408, %405 ], [ %1, %417 ]
br label %162
417: ; preds = %405
%418 = icmp ne i32 %406, 0
%419 = and i1 %80, %418
br i1 %419, label %411, label %85
420: ; preds = %155, %420
%421 = phi i64 [ %442, %420 ], [ %156, %155 ]
%422 = phi i64 [ %441, %420 ], [ %157, %155 ]
%423 = getelementptr inbounds double, double* %0, i64 %421
%424 = load double, double* %423
%425 = getelementptr inbounds double, double* %2, i64 %422
store double %424, double* %425
%426 = add nuw nsw i64 %422, 1
%427 = add nsw i64 %421, %90
%428 = getelementptr inbounds double, double* %0, i64 %427
%429 = load double, double* %428
%430 = getelementptr inbounds double, double* %2, i64 %426
store double %429, double* %430
%431 = add nuw nsw i64 %422, 2
%432 = add nsw i64 %427, %90
%433 = getelementptr inbounds double, double* %0, i64 %432
%434 = load double, double* %433
%435 = getelementptr inbounds double, double* %2, i64 %431
store double %434, double* %435
%436 = add nuw nsw i64 %422, 3
%437 = add nsw i64 %432, %90
%438 = getelementptr inbounds double, double* %0, i64 %437
%439 = load double, double* %438
%440 = getelementptr inbounds double, double* %2, i64 %436
store double %439, double* %440
%441 = add nuw nsw i64 %422, 4
%442 = add nsw i64 %437, %90
%443 = icmp eq i64 %441, %91
br i1 %443, label %444, label %420
444: ; preds = %155, %420, %135, %87
ret i32 0
}