#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];
  for (i = 0; i < n; i++) {
    int m = i;
    double Em = fabs(E[i]);
    for (j = i + 1; j < n; j++) {
      double Ej = fabs(E[j]);
      m = (Em < Ej) ? j : m;
      Em = (Em < Ej) ? Ej : Em;
    }
    if (m != i) {
      int l;
      double b = E[i];
      E[i] = E[m];
      E[m] = b;
      for (j = 0, k = i * n, l = m * n; j < n; j++, k++, l++) {
        b = V[k];
        V[k] = V[l];
        V[l] = b;
      }
    }
  }
  return 0;
}


x86 assembly (clang, -O0):
<cvJacobiEigens_64d>:
push   %rbp
mov    %rsp,%rbp
sub    $0x160,%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,-0x140(%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  -0x140(%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,-0x148(%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  -0x148(%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>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1de3 <cvJacobiEigens_64d+0xcd3>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x114(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x429(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1cd5 <cvJacobiEigens_64d+0xbc5>
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x3f4(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x120(%rbp),%xmm1
ff
movsd  -0x128(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    1c60 <cvJacobiEigens_64d+0xb50>
mov    -0x30(%rbp),%eax
mov    %eax,-0x14c(%rbp)
jmp    1c6c <cvJacobiEigens_64d+0xb5c>
mov    -0x114(%rbp),%eax
mov    %eax,-0x14c(%rbp)
mov    -0x14c(%rbp),%eax
mov    %eax,-0x114(%rbp)
movsd  -0x120(%rbp),%xmm1
ff
movsd  -0x128(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    1ca7 <cvJacobiEigens_64d+0xb97>
movsd  -0x128(%rbp),%xmm0
ff
movsd  %xmm0,-0x158(%rbp)
ff
jmp    1cb7 <cvJacobiEigens_64d+0xba7>
movsd  -0x120(%rbp),%xmm0
ff
movsd  %xmm0,-0x158(%rbp)
ff
movsd  -0x158(%rbp),%xmm0
ff
movsd  %xmm0,-0x120(%rbp)
ff
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1c0c <cvJacobiEigens_64d+0xafc>
mov    -0x114(%rbp),%eax
cmp    -0x2c(%rbp),%eax
je     1dd0 <cvJacobiEigens_64d+0xcc0>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
mov    -0x18(%rbp),%rax
movslq -0x114(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x138(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x114(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x30(%rbp)
mov    -0x2c(%rbp),%eax
imul   -0x1c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x114(%rbp),%eax
imul   -0x1c(%rbp),%eax
mov    %eax,-0x12c(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1dcb <cvJacobiEigens_64d+0xcbb>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x12c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x138(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x12c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x12c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x12c(%rbp)
jmp    1d4f <cvJacobiEigens_64d+0xc3f>
jmp    1dd0 <cvJacobiEigens_64d+0xcc0>
jmp    1dd5 <cvJacobiEigens_64d+0xcc5>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1bce <cvJacobiEigens_64d+0xabe>
xor    %eax,%eax
add    $0x160,%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,0x70(%rsp)
mov    %rdx,0x60(%rsp)
mov    %rsi,0x28(%rsp)
movsd  0xeb7(%rip),%xmm0
movsd  %xmm0,0x58(%rsp)
mov    %ecx,%eax
xorpd  %xmm2,%xmm2
mov    %rcx,(%rsp)
test   %ecx,%ecx
mov    %rax,0x38(%rsp)
mov    %rdi,0x10(%rsp)
jle    126b <cvJacobiEigens_64d+0x14b>
lea    0x0(,%rax,8),%r15
xorpd  %xmm2,%xmm2
xor    %ebx,%ebx
movabs $0x3ff0000000000000,%r14
mov    %rdi,%rbp
mov    0x28(%rsp),%r12
jmp    11cb <cvJacobiEigens_64d+0xab>
nopl   (%rax)
movsd  %xmm2,0x40(%rsp)
mov    %r12,%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1030 <memset@plt>
movsd  0x40(%rsp),%xmm2
mov    %r14,(%r12,%rbx,8)
add    $0x1,%rbx
mov    0x38(%rsp),%rax
lea    (%r12,%rax,8),%r12
add    %r15,%rbp
cmp    %rax,%rbx
mov    0x10(%rsp),%rdi
je     126b <cvJacobiEigens_64d+0x14b>
test   %rbx,%rbx
je     1190 <cvJacobiEigens_64d+0x70>
lea    -0x1(%rbx),%rax
cmp    $0x3,%rax
jae    11e0 <cvJacobiEigens_64d+0xc0>
xor    %eax,%eax
jmp    1231 <cvJacobiEigens_64d+0x111>
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    11f0 <cvJacobiEigens_64d+0xd0>
test   $0x3,%bl
je     1190 <cvJacobiEigens_64d+0x70>
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    1250 <cvJacobiEigens_64d+0x130>
jmp    1190 <cvJacobiEigens_64d+0x70>
mov    (%rsp),%rbp
xorps  %xmm0,%xmm0
cvtsi2sd %ebp,%xmm0
movsd  %xmm0,0x90(%rsp)
movsd  0x58(%rsp),%xmm0
maxsd  0x70(%rsp),%xmm0
movsd  %xmm0,0x58(%rsp)
addsd  %xmm2,%xmm2
ucomisd 0xd7b(%rip),%xmm2
jb     12a6 <cvJacobiEigens_64d+0x186>
sqrtsd %xmm2,%xmm9
jmp    12be <cvJacobiEigens_64d+0x19e>
movapd %xmm2,%xmm0
call   1040 <sqrt@plt>
mov    0x10(%rsp),%rdi
mov    0x38(%rsp),%rax
movapd %xmm0,%xmm9
mov    0x28(%rsp),%r8
movsd  0x58(%rsp),%xmm0
mulsd  %xmm9,%xmm0
divsd  0x90(%rsp),%xmm0
movsd  %xmm0,0x58(%rsp)
ucomisd %xmm0,%xmm9
jbe    1af7 <cvJacobiEigens_64d+0x9d7>
movabs $0x1fffffffc,%rdx
lea    -0x1(%rbp),%ecx
mov    %rcx,0xc0(%rsp)
movslq %ebp,%r10
lea    0x1(%r10),%rcx
mov    %rcx,0xb8(%rsp)
lea    0x0(,%r10,8),%rsi
movapd 0xd03(%rip),%xmm10
xorpd  %xmm11,%xmm11
add    $0x2,%rdx
mov    %rdx,0xc8(%rsp)
mov    %r10,0xa0(%rsp)
mov    %rsi,0x30(%rsp)
jmp    1351 <cvJacobiEigens_64d+0x231>
nopl   (%rax)
ucomisd 0x58(%rsp),%xmm9
mov    (%rsp),%rbp
jbe    1af7 <cvJacobiEigens_64d+0x9d7>
divsd  0x90(%rsp),%xmm9
cmp    $0x2,%ebp
jl     1340 <cvJacobiEigens_64d+0x220>
xor    %r15d,%r15d
mov    $0x1,%ecx
xor    %r9d,%r9d
mov    %rdi,%r12
mov    %r8,%r13
movsd  %xmm9,0xa8(%rsp)
nopl   0x0(%rax,%rax,1)
mov    %rcx,0x98(%rsp)
lea    0x1(%r15),%rbp
cmp    %r10,%rbp
mov    %rbp,0xd0(%rsp)
jge    1a90 <cvJacobiEigens_64d+0x970>
mov    %r15,%rcx
imul   %r10,%rcx
lea    (%rdi,%rcx,8),%rdx
add    $0x8,%rdx
mov    %rdx,0xe8(%rsp)
mov    0xb8(%rsp),%rdx
add    %rcx,%rdx
mov    %rdx,0xe0(%rsp)
lea    (%r8,%rcx,8),%rcx
add    $0x8,%rcx
mov    %rcx,0xd8(%rsp)
mov    %rbp,%rcx
imul   %r10,%rcx
lea    (%r8,%rcx,8),%r14
lea    (%rdi,%rcx,8),%rbx
mov    0x98(%rsp),%rcx
lea    0x0(,%rcx,8),%rbp
xor    %r10d,%r10d
mov    %rcx,%rdx
jmp    1494 <cvJacobiEigens_64d+0x374>
cs nopw 0x0(%rax,%rax,1)
nopl   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,(%r12,%r15,8)
movsd  %xmm13,(%rbx,%rdx,8)
movq   $0x0,(%rbx,%r15,8)
movq   $0x0,(%r12,%rdx,8)
mov    $0x1,%r9d
mov    0x38(%rsp),%rax
add    $0x1,%rdx
add    %rsi,%rbx
add    %rsi,%r14
add    $0x1,%r10
add    $0x8,%rbp
cmp    %rax,%rdx
je     1a90 <cvJacobiEigens_64d+0x970>
movsd  (%r12,%rdx,8),%xmm2
movapd %xmm2,%xmm0
andpd  %xmm10,%xmm0
ucomisd %xmm0,%xmm9
ja     1479 <cvJacobiEigens_64d+0x359>
movsd  (%r12,%r15,8),%xmm3
movsd  (%rbx,%rdx,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    %r10,0x20(%rsp)
mov    %rdx,0x18(%rsp)
movapd %xmm2,0x70(%rsp)
movsd  %xmm3,0x68(%rsp)
movsd  %xmm4,0xb0(%rsp)
jb     1510 <cvJacobiEigens_64d+0x3f0>
sqrtsd %xmm0,%xmm0
jmp    152c <cvJacobiEigens_64d+0x40c>
cs nopw 0x0(%rax,%rax,1)
nop
movapd %xmm5,0x40(%rsp)
call   1040 <sqrt@plt>
movapd 0x40(%rsp),%xmm5
movapd 0x70(%rsp),%xmm2
xorpd  %xmm11,%xmm11
movapd %xmm2,%xmm3
movapd 0xaf8(%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  0xaa6(%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)
nopl   0x0(%rax,%rax,1)
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    162a <cvJacobiEigens_64d+0x50a>
nopl   0x0(%rax)
movapd %xmm15,0x40(%rsp)
movapd %xmm7,0x80(%rsp)
call   1040 <sqrt@plt>
movapd 0x80(%rsp),%xmm7
movapd 0x40(%rsp),%xmm15
xorpd  %xmm11,%xmm11
mov    0x10(%rsp),%rdi
movsd  0xa8(%rsp),%xmm9
mov    0x30(%rsp),%rsi
movapd 0x9d9(%rip),%xmm10
mov    (%rsp),%r9
mov    0x20(%rsp),%r10
mov    0x18(%rsp),%rdx
movapd 0x70(%rsp),%xmm12
movsd  0x68(%rsp),%xmm13
movsd  0xb0(%rsp),%xmm14
test   %r15,%r15
je     1705 <cvJacobiEigens_64d+0x5e5>
mov    %rdi,%rax
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movsd  (%rax,%r15,8),%xmm1
movsd  (%rax,%rbp,1),%xmm2
movsd  0x0(%r13,%rcx,8),%xmm3
movsd  (%r14,%rcx,8),%xmm4
movapd %xmm15,%xmm5
mulsd  %xmm2,%xmm5
movapd %xmm15,%xmm6
mulsd  %xmm1,%xmm6
mulsd  %xmm0,%xmm1
subsd  %xmm5,%xmm1
movsd  %xmm1,(%rax,%r15,8)
mulsd  %xmm0,%xmm2
addsd  %xmm6,%xmm2
movsd  %xmm2,(%rax,%rbp,1)
movapd %xmm15,%xmm1
mulsd  %xmm4,%xmm1
movapd %xmm15,%xmm2
mulsd  %xmm3,%xmm2
mulsd  %xmm0,%xmm3
subsd  %xmm1,%xmm3
movsd  %xmm3,0x0(%r13,%rcx,8)
mulsd  %xmm0,%xmm4
addsd  %xmm2,%xmm4
movsd  %xmm4,(%r14,%rcx,8)
add    $0x1,%rcx
add    %rsi,%rax
cmp    %rcx,%r15
jne    1680 <cvJacobiEigens_64d+0x560>
mov    %r15d,%r8d
jmp    170b <cvJacobiEigens_64d+0x5eb>
xor    %r8d,%r8d
mov    %rdi,%rax
mov    %r8d,%ecx
cmp    %rcx,%rdx
jbe    17a1 <cvJacobiEigens_64d+0x681>
lea    (%rax,%rdx,8),%rax
nopl   0x0(%rax,%rax,1)
movsd  (%r12,%rcx,8),%xmm1
movsd  (%rax),%xmm2
movsd  0x0(%r13,%rcx,8),%xmm3
movsd  (%r14,%rcx,8),%xmm4
movapd %xmm15,%xmm5
mulsd  %xmm2,%xmm5
movapd %xmm15,%xmm6
mulsd  %xmm1,%xmm6
mulsd  %xmm0,%xmm1
subsd  %xmm5,%xmm1
movsd  %xmm1,(%r12,%rcx,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(%r13,%rcx,8)
mulsd  %xmm0,%xmm4
addsd  %xmm2,%xmm4
movsd  %xmm4,(%r14,%rcx,8)
add    $0x1,%rcx
add    %rsi,%rax
cmp    %rcx,%rdx
jne    1720 <cvJacobiEigens_64d+0x600>
mov    %edx,%r8d
cmp    %r9d,%r8d
jge    1410 <cvJacobiEigens_64d+0x2f0>
mov    %r8d,%eax
not    %r8d
add    %r9d,%r8d
je     19e0 <cvJacobiEigens_64d+0x8c0>
mov    %r10,%rcx
imul   0xa0(%rsp),%rcx
add    0xe0(%rsp),%rcx
lea    (%rdi,%rcx,8),%r9
mov    0x28(%rsp),%rdx
lea    (%rdx,%rcx,8),%rcx
mov    %rcx,0x40(%rsp)
lea    (%r12,%rax,8),%rdx
lea    (%r8,%rax,1),%rdi
mov    0xe8(%rsp),%rcx
lea    (%rcx,%rdi,8),%r10
mov    %rbx,0x50(%rsp)
lea    (%rbx,%rax,8),%rsi
lea    (%r9,%rdi,8),%r9
lea    0x0(%r13,%rax,8),%r11
mov    0xd8(%rsp),%rcx
lea    (%rcx,%rdi,8),%rcx
mov    %rcx,0xf0(%rsp)
lea    (%r14,%rax,8),%rcx
mov    0x40(%rsp),%rbx
lea    (%rbx,%rdi,8),%rbx
cmp    %r9,%rdx
setb   0x40(%rsp)
cmp    %r10,%rsi
setb   0x80(%rsp)
mov    0xf0(%rsp),%rdi
cmp    %rdi,%rdx
setb   0xf(%rsp)
cmp    %r10,%r11
setb   0xe(%rsp)
cmp    %rbx,%rdx
setb   0xd(%rsp)
cmp    %r10,%rcx
setb   0xc(%rsp)
cmp    %rdi,%rsi
mov    %rdi,%r10
setb   %dil
cmp    %r9,%r11
setb   0xb(%rsp)
cmp    %rbx,%rsi
setb   0xa(%rsp)
cmp    %r9,%rcx
setb   0x9(%rsp)
cmp    %rbx,%r11
setb   %r9b
cmp    %r10,%rcx
setb   %r10b
mov    0x80(%rsp),%bl
test   %bl,0x40(%rsp)
jne    1a62 <cvJacobiEigens_64d+0x942>
mov    %r10b,0x40(%rsp)
mov    %r9d,%r10d
mov    0xe(%rsp),%bl
and    %bl,0xf(%rsp)
mov    (%rsp),%r9
jne    19c7 <cvJacobiEigens_64d+0x8a7>
mov    0xc(%rsp),%bl
and    %bl,0xd(%rsp)
jne    19c7 <cvJacobiEigens_64d+0x8a7>
and    0xb(%rsp),%dil
jne    19c7 <cvJacobiEigens_64d+0x8a7>
mov    0x9(%rsp),%bl
and    %bl,0xa(%rsp)
jne    19c7 <cvJacobiEigens_64d+0x8a7>
and    0x40(%rsp),%r10b
jne    19c7 <cvJacobiEigens_64d+0x8a7>
movapd %xmm7,0x80(%rsp)
add    $0x1,%r8
mov    %r8,%r9
and    0xc8(%rsp),%r9
add    %r9,%rax
movapd %xmm15,%xmm8
unpcklpd %xmm15,%xmm8
movapd %xmm0,%xmm2
unpcklpd %xmm0,%xmm2
xor    %ebx,%ebx
nopl   (%rax)
movupd (%rdx,%rbx,8),%xmm3
movupd (%rsi,%rbx,8),%xmm4
movupd (%r11,%rbx,8),%xmm5
movupd (%rcx,%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,(%r11,%rbx,8)
mulpd  %xmm2,%xmm6
addpd  %xmm3,%xmm6
movupd %xmm6,(%rcx,%rbx,8)
add    $0x2,%rbx
cmp    %rbx,%r9
jne    1920 <cvJacobiEigens_64d+0x800>
cmp    %r9,%r8
mov    (%rsp),%r9
mov    0x30(%rsp),%rsi
mov    0x50(%rsp),%rbx
mov    0x20(%rsp),%r10
mov    0x18(%rsp),%rdx
movapd 0x80(%rsp),%xmm7
mov    0x10(%rsp),%rdi
jne    19e0 <cvJacobiEigens_64d+0x8c0>
jmp    1410 <cvJacobiEigens_64d+0x2f0>
mov    0x30(%rsp),%rsi
mov    0x50(%rsp),%rbx
mov    0x20(%rsp),%r10
mov    0x18(%rsp),%rdx
mov    0x10(%rsp),%rdi
movsd  (%r12,%rax,8),%xmm1
movsd  (%rbx,%rax,8),%xmm2
movsd  0x0(%r13,%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,(%r12,%rax,8)
mulsd  %xmm0,%xmm2
addsd  %xmm6,%xmm2
movsd  %xmm2,(%rbx,%rax,8)
movapd %xmm15,%xmm1
mulsd  %xmm4,%xmm1
movapd %xmm15,%xmm2
mulsd  %xmm3,%xmm2
mulsd  %xmm0,%xmm3
subsd  %xmm1,%xmm3
movsd  %xmm3,0x0(%r13,%rax,8)
mulsd  %xmm0,%xmm4
addsd  %xmm2,%xmm4
movsd  %xmm4,(%r14,%rax,8)
add    $0x1,%rax
cmp    %r9d,%eax
jl     19e0 <cvJacobiEigens_64d+0x8c0>
jmp    1410 <cvJacobiEigens_64d+0x2f0>
mov    (%rsp),%r9
mov    0x10(%rsp),%rdi
mov    0x30(%rsp),%rsi
mov    0x50(%rsp),%rbx
mov    0x20(%rsp),%r10
mov    0x18(%rsp),%rdx
jmp    19e0 <cvJacobiEigens_64d+0x8c0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0xa0(%rsp),%r10
lea    (%r12,%r10,8),%r12
lea    0x0(%r13,%r10,8),%r13
mov    0x98(%rsp),%rcx
add    $0x1,%rcx
mov    0xd0(%rsp),%rdx
mov    %rdx,%r15
cmp    0xc0(%rsp),%rdx
mov    0x28(%rsp),%r8
jne    1380 <cvJacobiEigens_64d+0x260>
cmpl   $0x2,(%rsp)
jl     1340 <cvJacobiEigens_64d+0x220>
xor    %r15d,%r15d
mov    $0x1,%ecx
mov    %rdi,%r12
mov    %r8,%r13
test   %r9d,%r9d
mov    $0x0,%r9d
jne    1380 <cvJacobiEigens_64d+0x260>
jmp    1340 <cvJacobiEigens_64d+0x220>
test   %ebp,%ebp
mov    0x60(%rsp),%r15
jle    1f76 <cvJacobiEigens_64d+0xe56>
lea    0x1(%rbp),%eax
movslq %eax,%r10
cmp    $0x4,%ebp
jae    1b1d <cvJacobiEigens_64d+0x9fd>
xor    %ecx,%ecx
xor    %edx,%edx
mov    0x38(%rsp),%r8
jmp    1bd0 <cvJacobiEigens_64d+0xab0>
mov    0x38(%rsp),%r8
lea    -0x1(%r8),%rcx
imul   %r10,%rcx
lea    (%rdi,%rcx,8),%rdx
cmp    %rdi,%rdx
mov    %rdx,%rcx
cmova  %rdi,%rcx
cmovb  %rdi,%rdx
add    $0x8,%rdx
cmp    %r15,%rdx
jbe    1b54 <cvJacobiEigens_64d+0xa34>
lea    (%r15,%r8,8),%rdx
cmp    %rdx,%rcx
jae    1b54 <cvJacobiEigens_64d+0xa34>
xor    %ecx,%ecx
xor    %edx,%edx
jmp    1bd0 <cvJacobiEigens_64d+0xab0>
mov    %r8d,%edx
and    $0xfffffffc,%edx
mov    %rdx,%rcx
imul   %r10,%rcx
lea    0x0(,%r8,8),%r8
and    $0xffffffffffffffe0,%r8
mov    %r10,%rax
shl    $0x5,%rax
lea    0x0(,%r10,8),%rsi
lea    (%rsi,%rsi,2),%r9
mov    %r10,%rbx
shl    $0x4,%rbx
xor    %esi,%esi
mov    %rdi,%rbp
nopl   0x0(%rax)
movsd  0x0(%rbp),%xmm0
movhpd 0x0(%rbp,%r10,8),%xmm0
movsd  0x0(%rbp,%rbx,1),%xmm1
movhpd 0x0(%rbp,%r9,1),%xmm1
movupd %xmm0,(%r15,%rsi,1)
movupd %xmm1,0x10(%r15,%rsi,1)
add    $0x20,%rsi
add    %rax,%rbp
cmp    %rsi,%r8
jne    1b90 <cvJacobiEigens_64d+0xa70>
mov    0x38(%rsp),%r8
cmp    %r8,%rdx
je     1c7c <cvJacobiEigens_64d+0xb5c>
mov    %rdx,%rsi
not    %rsi
add    %r8,%rsi
mov    %r8,%rax
and    $0x3,%rax
je     1c08 <cvJacobiEigens_64d+0xae8>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rdi,%rcx,8),%xmm0
movsd  %xmm0,(%r15,%rdx,8)
add    $0x1,%rdx
add    %r10,%rcx
add    $0xffffffffffffffff,%rax
jne    1bf0 <cvJacobiEigens_64d+0xad0>
cmp    $0x3,%rsi
jb     1c7c <cvJacobiEigens_64d+0xb5c>
lea    0x0(,%rcx,8),%r9
mov    %r10,%rsi
shl    $0x5,%rsi
lea    (%r10,%r10,2),%rbp
lea    (%r9,%rbp,8),%rbp
mov    %r10,%rax
shl    $0x4,%rax
lea    (%rax,%rcx,8),%rbx
add    %r10,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rdi,%r9,1),%xmm0
movsd  %xmm0,(%r15,%rdx,8)
movsd  (%rdi,%rcx,8),%xmm0
movsd  %xmm0,0x8(%r15,%rdx,8)
movsd  (%rdi,%rbx,1),%xmm0
movsd  %xmm0,0x10(%r15,%rdx,8)
movsd  (%rdi,%rbp,1),%xmm0
movsd  %xmm0,0x18(%r15,%rdx,8)
add    $0x4,%rdx
add    %rsi,%rdi
cmp    %rdx,%r8
jne    1c40 <cvJacobiEigens_64d+0xb20>
mov    (%rsp),%rax
test   %eax,%eax
jle    1f76 <cvJacobiEigens_64d+0xe56>
mov    %r8,%rbx
lea    -0x1(%rax),%r10d
mov    0x28(%rsp),%rcx
lea    (%rcx,%r10,8),%r12
add    $0x8,%r12
lea    0x1(%r10),%r9
mov    %r9,0x40(%rsp)
and    $0xfffffffffffffffc,%r9
lea    -0x4(%r9),%rdx
mov    %rdx,0x70(%rsp)
mov    %rdx,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %rsi,%rdx
mov    %rsi,0x20(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,0x18(%rsp)
mov    %eax,%r8d
neg    %r8d
lea    0x30(%rcx),%rax
mov    %rax,0x68(%rsp)
lea    0x8(%rcx),%r13
mov    $0x1,%edx
xor    %edi,%edi
movapd 0x330(%rip),%xmm0
xor    %esi,%esi
jmp    1d15 <cvJacobiEigens_64d+0xbf5>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rdx
add    (%rsp),%esi
mov    0x38(%rsp),%rbx
cmp    %rbx,%rdi
je     1f76 <cvJacobiEigens_64d+0xe56>
mov    %rdi,%rbp
movsd  (%r15,%rdi,8),%xmm1
add    $0x1,%rdi
cmp    %rbx,%rdi
jae    1d70 <cvJacobiEigens_64d+0xc50>
movapd %xmm1,%xmm2
andpd  %xmm0,%xmm2
mov    %rdx,%rax
mov    %ebp,%ebx
mov    0x38(%rsp),%rcx
nopl   0x0(%rax)
movsd  (%r15,%rax,8),%xmm3
andpd  %xmm0,%xmm3
ucomisd %xmm2,%xmm3
cmova  %eax,%ebx
maxsd  %xmm2,%xmm3
add    $0x1,%rax
movapd %xmm3,%xmm2
cmp    %rax,%rcx
jne    1d40 <cvJacobiEigens_64d+0xc20>
jmp    1d72 <cvJacobiEigens_64d+0xc52>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %ebp,%ebx
mov    %ebx,%eax
cmp    %rax,%rbp
je     1d00 <cvJacobiEigens_64d+0xbe0>
movslq %esi,%r11
movslq %ebx,%rax
imul   (%rsp),%ebx
mov    %r15,%rcx
xor    %r15d,%r15d
movsd  (%rcx,%rax,8),%xmm2
movsd  %xmm2,(%rcx,%rbp,8)
movsd  %xmm1,(%rcx,%rax,8)
movslq %ebx,%r14
cmp    $0x3,%r10d
jae    1db0 <cvJacobiEigens_64d+0xc90>
mov    (%rsp),%rax
mov    0x28(%rsp),%rbx
jmp    1ddb <cvJacobiEigens_64d+0xcbb>
nopl   0x0(%rax)
mov    0x28(%rsp),%rbx
lea    (%rbx,%r11,8),%rax
lea    (%r12,%r14,8),%rcx
cmp    %rcx,%rax
jae    1e89 <cvJacobiEigens_64d+0xd69>
lea    (%r12,%r11,8),%rax
lea    (%rbx,%r14,8),%rcx
cmp    %rax,%rcx
jae    1e89 <cvJacobiEigens_64d+0xd69>
mov    (%rsp),%rax
sub    %r15d,%eax
test   $0x1,%al
jne    1df0 <cvJacobiEigens_64d+0xcd0>
mov    %r15d,%ebx
jmp    1e14 <cvJacobiEigens_64d+0xcf4>
nopw   0x0(%rax,%rax,1)
movsd  (%rbx,%r11,8),%xmm1
movsd  (%rbx,%r14,8),%xmm2
movsd  %xmm2,(%rbx,%r11,8)
movsd  %xmm1,(%rbx,%r14,8)
lea    0x1(%r15),%ebx
add    $0x1,%r11
add    $0x1,%r14
not    %r15d
cmp    %r8d,%r15d
mov    0x60(%rsp),%r15
je     1d00 <cvJacobiEigens_64d+0xbe0>
lea    0x0(,%r11,8),%rax
add    %r13,%rax
lea    0x0(,%r14,8),%rcx
add    %r13,%rcx
mov    (%rsp),%rbp
sub    %ebx,%ebp
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  -0x8(%rax,%rbx,8),%xmm1
movsd  -0x8(%rcx,%rbx,8),%xmm2
movsd  %xmm2,-0x8(%rax,%rbx,8)
movsd  %xmm1,-0x8(%rcx,%rbx,8)
movsd  (%rax,%rbx,8),%xmm1
movsd  (%rcx,%rbx,8),%xmm2
movsd  %xmm2,(%rax,%rbx,8)
movsd  %xmm1,(%rcx,%rbx,8)
add    $0x2,%rbx
cmp    %ebx,%ebp
jne    1e50 <cvJacobiEigens_64d+0xd30>
jmp    1d00 <cvJacobiEigens_64d+0xbe0>
cmpq   $0x0,0x70(%rsp)
je     1f66 <cvJacobiEigens_64d+0xe46>
mov    0x68(%rsp),%rcx
lea    (%rcx,%r11,8),%rax
lea    (%rcx,%r14,8),%rcx
mov    0x18(%rsp),%rbp
xor    %ebx,%ebx
mov    0x60(%rsp),%r15
xchg   %ax,%ax
movups -0x30(%rax,%rbx,8),%xmm1
movups -0x20(%rax,%rbx,8),%xmm2
movups -0x30(%rcx,%rbx,8),%xmm3
movups -0x20(%rcx,%rbx,8),%xmm4
movups %xmm3,-0x30(%rax,%rbx,8)
movups %xmm4,-0x20(%rax,%rbx,8)
movups %xmm1,-0x30(%rcx,%rbx,8)
movups %xmm2,-0x20(%rcx,%rbx,8)
movupd -0x10(%rax,%rbx,8),%xmm1
movupd (%rax,%rbx,8),%xmm2
movupd -0x10(%rcx,%rbx,8),%xmm3
movupd (%rcx,%rbx,8),%xmm4
movupd %xmm3,-0x10(%rax,%rbx,8)
movupd %xmm4,(%rax,%rbx,8)
movupd %xmm1,-0x10(%rcx,%rbx,8)
movupd %xmm2,(%rcx,%rbx,8)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%rbp
jne    1eb0 <cvJacobiEigens_64d+0xd90>
testb  $0x1,0x20(%rsp)
je     1f4d <cvJacobiEigens_64d+0xe2d>
lea    (%rbx,%r11,1),%rax
add    %r14,%rbx
mov    0x28(%rsp),%rcx
movupd (%rcx,%rax,8),%xmm1
movupd 0x10(%rcx,%rax,8),%xmm2
movupd (%rcx,%rbx,8),%xmm3
movupd 0x10(%rcx,%rbx,8),%xmm4
movupd %xmm3,(%rcx,%rax,8)
movupd %xmm4,0x10(%rcx,%rax,8)
movupd %xmm1,(%rcx,%rbx,8)
movupd %xmm2,0x10(%rcx,%rbx,8)
cmp    %r9,0x40(%rsp)
je     1d00 <cvJacobiEigens_64d+0xbe0>
add    %r9,%r11
add    %r9,%r14
mov    %r9d,%r15d
jmp    1da1 <cvJacobiEigens_64d+0xc81>
xor    %ebx,%ebx
mov    0x60(%rsp),%r15
testb  $0x1,0x20(%rsp)
jne    1f15 <cvJacobiEigens_64d+0xdf5>
jmp    1f4d <cvJacobiEigens_64d+0xe2d>
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
%43 = alloca i32
%44 = alloca double
%45 = alloca double
%46 = alloca i32
%47 = 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
%48 = load double*, double** %6
store double* %48, double** %17
%49 = load double*, double** %7
store double* %49, double** %18
%50 = load double*, double** %6
store double* %50, double** %19
%51 = load double*, double** %7
store double* %51, double** %20
store double 0.000000e+00, double* %21
store double 0.000000e+00, double* %22
%52 = load double, double* %10
%53 = fcmp olt double %52, 1.000000e-15
br i1 %53, label %54, label %55
54: ; preds = %5
store double 1.000000e-15, double* %10
br label %55
55: ; preds = %54, %5
%56 = load double, double* %10
%57 = load i32, i32* %9
%58 = sitofp i32 %57 to double
%59 = fdiv double %56, %58
store double %59, double* %24
store i32 0, i32* %11
br label %60
60: ; preds = %100, %55
%61 = load i32, i32* %11
%62 = load i32, i32* %9
%63 = icmp slt i32 %61, %62
br i1 %63, label %64, label %111
64: ; preds = %60
store i32 0, i32* %12
br label %65
65: ; preds = %79, %64
%66 = load i32, i32* %12
%67 = load i32, i32* %11
%68 = icmp slt i32 %66, %67
br i1 %68, label %69, label %82
69: ; preds = %65
%70 = load double*, double** %17
%71 = load i32, i32* %12
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds double, double* %70, i64 %72
%74 = load double, double* %73
store double %74, double* %25
%75 = load double, double* %25
%76 = load double, double* %25
%77 = load double, double* %22
%78 = call double @llvm.fmuladd.f64(double %75, double %76, double %77)
store double %78, double* %22
br label %79
79: ; preds = %69
%80 = load i32, i32* %12
%81 = add nsw i32 %80, 1
store i32 %81, i32* %12
br label %65
82: ; preds = %65
store i32 0, i32* %12
br label %83
83: ; preds = %92, %82
%84 = load i32, i32* %12
%85 = load i32, i32* %9
%86 = icmp slt i32 %84, %85
br i1 %86, label %87, label %95
87: ; preds = %83
%88 = load double*, double** %18
%89 = load i32, i32* %12
%90 = sext i32 %89 to i64
%91 = getelementptr inbounds double, double* %88, i64 %90
store double 0.000000e+00, double* %91
br label %92
92: ; preds = %87
%93 = load i32, i32* %12
%94 = add nsw i32 %93, 1
store i32 %94, i32* %12
br label %83
95: ; preds = %83
%96 = load double*, double** %18
%97 = load i32, i32* %11
%98 = sext i32 %97 to i64
%99 = getelementptr inbounds double, double* %96, i64 %98
store double 1.000000e+00, double* %99
br label %100
100: ; preds = %95
%101 = load i32, i32* %11
%102 = add nsw i32 %101, 1
store i32 %102, i32* %11
%103 = load i32, i32* %9
%104 = load double*, double** %18
%105 = sext i32 %103 to i64
%106 = getelementptr inbounds double, double* %104, i64 %105
store double* %106, double** %18
%107 = load i32, i32* %9
%108 = load double*, double** %17
%109 = sext i32 %107 to i64
%110 = getelementptr inbounds double, double* %108, i64 %109
store double* %110, double** %17
br label %60
111: ; preds = %60
%112 = load double, double* %22
%113 = load double, double* %22
%114 = fadd double %112, %113
%115 = call double @sqrt(double %114)
store double %115, double* %22
%116 = load double, double* %22
%117 = load double, double* %10
%118 = fmul double %116, %117
%119 = load i32, i32* %9
%120 = sitofp i32 %119 to double
%121 = fdiv double %118, %120
store double %121, double* %23
%122 = load double, double* %22
store double %122, double* %21
br label %123
123: ; preds = %515, %111
%124 = load double, double* %21
%125 = load double, double* %23
%126 = fcmp ogt double %124, %125
br i1 %126, label %127, label %516
127: ; preds = %123
%128 = load i32, i32* %9
%129 = sitofp i32 %128 to double
%130 = load double, double* %21
%131 = fdiv double %130, %129
store double %131, double* %21
br label %132
132: ; preds = %512, %127
store i32 0, i32* %16
%133 = load double*, double** %6
store double* %133, double** %17
%134 = load double*, double** %7
store double* %134, double** %18
store i32 0, i32* %14
br label %135
135: ; preds = %500, %132
%136 = load i32, i32* %14
%137 = load i32, i32* %9
%138 = sub nsw i32 %137, 1
%139 = icmp slt i32 %136, %138
br i1 %139, label %140, label %511
140: ; preds = %135
%141 = load double*, double** %6
%142 = load i32, i32* %9
%143 = load i32, i32* %14
%144 = add nsw i32 %143, 1
%145 = mul nsw i32 %142, %144
%146 = sext i32 %145 to i64
%147 = getelementptr inbounds double, double* %141, i64 %146
store double* %147, double** %19
%148 = load double*, double** %7
%149 = load i32, i32* %9
%150 = load i32, i32* %14
%151 = add nsw i32 %150, 1
%152 = mul nsw i32 %149, %151
%153 = sext i32 %152 to i64
%154 = getelementptr inbounds double, double* %148, i64 %153
store double* %154, double** %20
%155 = load i32, i32* %14
%156 = add nsw i32 %155, 1
store i32 %156, i32* %15
br label %157
157: ; preds = %488, %140
%158 = load i32, i32* %15
%159 = load i32, i32* %9
%160 = icmp slt i32 %158, %159
br i1 %160, label %161, label %499
161: ; preds = %157
%162 = load double*, double** %17
%163 = load i32, i32* %15
%164 = sext i32 %163 to i64
%165 = getelementptr inbounds double, double* %162, i64 %164
%166 = load double, double* %165
%167 = call double @llvm.fabs.f64(double %166)
%168 = load double, double* %21
%169 = fcmp olt double %167, %168
br i1 %169, label %170, label %171
170: ; preds = %161
br label %488
171: ; preds = %161
%172 = load double*, double** %17
%173 = load i32, i32* %15
%174 = sext i32 %173 to i64
%175 = getelementptr inbounds double, double* %172, i64 %174
%176 = load double, double* %175
store double %176, double* %34
store i32 1, i32* %16
%177 = load double*, double** %17
%178 = load i32, i32* %14
%179 = sext i32 %178 to i64
%180 = getelementptr inbounds double, double* %177, i64 %179
%181 = load double, double* %180
store double %181, double* %35
%182 = load double*, double** %19
%183 = load i32, i32* %15
%184 = sext i32 %183 to i64
%185 = getelementptr inbounds double, double* %182, i64 %184
%186 = load double, double* %185
store double %186, double* %36
%187 = load double, double* %35
%188 = load double, double* %36
%189 = fsub double %187, %188
%190 = fmul double 5.000000e-01, %189
store double %190, double* %27
%191 = load double, double* %34
%192 = fneg double %191
%193 = load double, double* %34
%194 = load double, double* %34
%195 = load double, double* %27
%196 = load double, double* %27
%197 = fmul double %195, %196
%198 = call double @llvm.fmuladd.f64(double %193, double %194, double %197)
%199 = call double @sqrt(double %198)
%200 = fdiv double %192, %199
store double %200, double* %26
%201 = load double, double* %27
%202 = fcmp olt double %201, 0.000000e+00
br i1 %202, label %203, label %206
203: ; preds = %171
%204 = load double, double* %26
%205 = fneg double %204
store double %205, double* %26
br label %206
206: ; preds = %203, %171
%207 = load double, double* %26
%208 = load double, double* %26
%209 = load double, double* %26
%210 = fneg double %208
%211 = call double @llvm.fmuladd.f64(double %210, double %209, double 1.000000e+00)
%212 = call double @sqrt(double %211)
%213 = fadd double 1.000000e+00, %212
%214 = fmul double 2.000000e+00, %213
%215 = call double @sqrt(double %214)
%216 = fdiv double %207, %215
store double %216, double* %29
%217 = load double, double* %29
%218 = load double, double* %29
%219 = fmul double %217, %218
store double %219, double* %31
%220 = load double, double* %31
%221 = fsub double 1.000000e+00, %220
%222 = call double @sqrt(double %221)
store double %222, double* %28
%223 = load double, double* %28
%224 = load double, double* %28
%225 = fmul double %223, %224
store double %225, double* %30
%226 = load double, double* %34
%227 = fmul double 2.000000e+00, %226
%228 = load double, double* %28
%229 = fmul double %227, %228
%230 = load double, double* %29
%231 = fmul double %229, %230
store double %231, double* %32
%232 = load double*, double** %6
store double* %232, double** %33
store i32 0, i32* %11
br label %233
233: ; preds = %300, %206
%234 = load i32, i32* %11
%235 = load i32, i32* %14
%236 = icmp slt i32 %234, %235
br i1 %236, label %237, label %307
237: ; preds = %233
%238 = load double*, double** %33
%239 = load i32, i32* %14
%240 = sext i32 %239 to i64
%241 = getelementptr inbounds double, double* %238, i64 %240
%242 = load double, double* %241
store double %242, double* %39
%243 = load double*, double** %33
%244 = load i32, i32* %15
%245 = sext i32 %244 to i64
%246 = getelementptr inbounds double, double* %243, i64 %245
%247 = load double, double* %246
store double %247, double* %40
%248 = load double*, double** %18
%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* %41
%253 = load double*, double** %20
%254 = load i32, i32* %11
%255 = sext i32 %254 to i64
%256 = getelementptr inbounds double, double* %253, i64 %255
%257 = load double, double* %256
store double %257, double* %42
%258 = load double, double* %39
%259 = load double, double* %28
%260 = load double, double* %40
%261 = load double, double* %29
%262 = fmul double %260, %261
%263 = fneg double %262
%264 = call double @llvm.fmuladd.f64(double %258, double %259, double %263)
%265 = load double*, double** %33
%266 = load i32, i32* %14
%267 = sext i32 %266 to i64
%268 = getelementptr inbounds double, double* %265, i64 %267
store double %264, double* %268
%269 = load double, double* %40
%270 = load double, double* %28
%271 = load double, double* %39
%272 = load double, double* %29
%273 = fmul double %271, %272
%274 = call double @llvm.fmuladd.f64(double %269, double %270, double %273)
%275 = load double*, double** %33
%276 = load i32, i32* %15
%277 = sext i32 %276 to i64
%278 = getelementptr inbounds double, double* %275, i64 %277
store double %274, double* %278
%279 = load double, double* %41
%280 = load double, double* %28
%281 = load double, double* %42
%282 = load double, double* %29
%283 = fmul double %281, %282
%284 = fneg double %283
%285 = call double @llvm.fmuladd.f64(double %279, double %280, double %284)
%286 = load double*, double** %18
%287 = load i32, i32* %11
%288 = sext i32 %287 to i64
%289 = getelementptr inbounds double, double* %286, i64 %288
store double %285, double* %289
%290 = load double, double* %42
%291 = load double, double* %28
%292 = load double, double* %41
%293 = load double, double* %29
%294 = fmul double %292, %293
%295 = call double @llvm.fmuladd.f64(double %290, double %291, double %294)
%296 = load double*, double** %20
%297 = load i32, i32* %11
%298 = sext i32 %297 to i64
%299 = getelementptr inbounds double, double* %296, i64 %298
store double %295, double* %299
br label %300
300: ; preds = %237
%301 = load i32, i32* %11
%302 = add nsw i32 %301, 1
store i32 %302, i32* %11
%303 = load i32, i32* %9
%304 = load double*, double** %33
%305 = sext i32 %303 to i64
%306 = getelementptr inbounds double, double* %304, i64 %305
store double* %306, double** %33
br label %233
307: ; preds = %233
br label %308
308: ; preds = %375, %307
%309 = load i32, i32* %11
%310 = load i32, i32* %15
%311 = icmp slt i32 %309, %310
br i1 %311, label %312, label %382
312: ; preds = %308
%313 = load double*, double** %17
%314 = load i32, i32* %11
%315 = sext i32 %314 to i64
%316 = getelementptr inbounds double, double* %313, i64 %315
%317 = load double, double* %316
store double %317, double* %39
%318 = load double*, double** %33
%319 = load i32, i32* %15
%320 = sext i32 %319 to i64
%321 = getelementptr inbounds double, double* %318, i64 %320
%322 = load double, double* %321
store double %322, double* %40
%323 = load double*, double** %18
%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* %41
%328 = load double*, double** %20
%329 = load i32, i32* %11
%330 = sext i32 %329 to i64
%331 = getelementptr inbounds double, double* %328, i64 %330
%332 = load double, double* %331
store double %332, double* %42
%333 = load double, double* %39
%334 = load double, double* %28
%335 = load double, double* %40
%336 = load double, double* %29
%337 = fmul double %335, %336
%338 = fneg double %337
%339 = call double @llvm.fmuladd.f64(double %333, double %334, double %338)
%340 = load double*, double** %17
%341 = load i32, i32* %11
%342 = sext i32 %341 to i64
%343 = getelementptr inbounds double, double* %340, i64 %342
store double %339, double* %343
%344 = load double, double* %40
%345 = load double, double* %28
%346 = load double, double* %39
%347 = load double, double* %29
%348 = fmul double %346, %347
%349 = call double @llvm.fmuladd.f64(double %344, double %345, double %348)
%350 = load double*, double** %33
%351 = load i32, i32* %15
%352 = sext i32 %351 to i64
%353 = getelementptr inbounds double, double* %350, i64 %352
store double %349, double* %353
%354 = load double, double* %41
%355 = load double, double* %28
%356 = load double, double* %42
%357 = load double, double* %29
%358 = fmul double %356, %357
%359 = fneg double %358
%360 = call double @llvm.fmuladd.f64(double %354, double %355, double %359)
%361 = load double*, double** %18
%362 = load i32, i32* %11
%363 = sext i32 %362 to i64
%364 = getelementptr inbounds double, double* %361, i64 %363
store double %360, double* %364
%365 = load double, double* %42
%366 = load double, double* %28
%367 = load double, double* %41
%368 = load double, double* %29
%369 = fmul double %367, %368
%370 = call double @llvm.fmuladd.f64(double %365, double %366, double %369)
%371 = load double*, double** %20
%372 = load i32, i32* %11
%373 = sext i32 %372 to i64
%374 = getelementptr inbounds double, double* %371, i64 %373
store double %370, double* %374
br label %375
375: ; preds = %312
%376 = load i32, i32* %11
%377 = add nsw i32 %376, 1
store i32 %377, i32* %11
%378 = load i32, i32* %9
%379 = load double*, double** %33
%380 = sext i32 %378 to i64
%381 = getelementptr inbounds double, double* %379, i64 %380
store double* %381, double** %33
br label %308
382: ; preds = %308
br label %383
383: ; preds = %450, %382
%384 = load i32, i32* %11
%385 = load i32, i32* %9
%386 = icmp slt i32 %384, %385
br i1 %386, label %387, label %453
387: ; preds = %383
%388 = load double*, double** %17
%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* %39
%393 = load double*, double** %19
%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* %40
%398 = load double*, double** %18
%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* %41
%403 = load double*, double** %20
%404 = load i32, i32* %11
%405 = sext i32 %404 to i64
%406 = getelementptr inbounds double, double* %403, i64 %405
%407 = load double, double* %406
store double %407, double* %42
%408 = load double, double* %39
%409 = load double, double* %28
%410 = load double, double* %40
%411 = load double, double* %29
%412 = fmul double %410, %411
%413 = fneg double %412
%414 = call double @llvm.fmuladd.f64(double %408, double %409, double %413)
%415 = load double*, double** %17
%416 = load i32, i32* %11
%417 = sext i32 %416 to i64
%418 = getelementptr inbounds double, double* %415, i64 %417
store double %414, double* %418
%419 = load double, double* %40
%420 = load double, double* %28
%421 = load double, double* %39
%422 = load double, double* %29
%423 = fmul double %421, %422
%424 = call double @llvm.fmuladd.f64(double %419, double %420, double %423)
%425 = load double*, double** %19
%426 = load i32, i32* %11
%427 = sext i32 %426 to i64
%428 = getelementptr inbounds double, double* %425, i64 %427
store double %424, double* %428
%429 = load double, double* %41
%430 = load double, double* %28
%431 = load double, double* %42
%432 = load double, double* %29
%433 = fmul double %431, %432
%434 = fneg double %433
%435 = call double @llvm.fmuladd.f64(double %429, double %430, double %434)
%436 = load double*, double** %18
%437 = load i32, i32* %11
%438 = sext i32 %437 to i64
%439 = getelementptr inbounds double, double* %436, i64 %438
store double %435, double* %439
%440 = load double, double* %42
%441 = load double, double* %28
%442 = load double, double* %41
%443 = load double, double* %29
%444 = fmul double %442, %443
%445 = call double @llvm.fmuladd.f64(double %440, double %441, double %444)
%446 = load double*, double** %20
%447 = load i32, i32* %11
%448 = sext i32 %447 to i64
%449 = getelementptr inbounds double, double* %446, i64 %448
store double %445, double* %449
br label %450
450: ; preds = %387
%451 = load i32, i32* %11
%452 = add nsw i32 %451, 1
store i32 %452, i32* %11
br label %383
453: ; preds = %383
%454 = load double, double* %35
%455 = load double, double* %30
%456 = load double, double* %36
%457 = load double, double* %31
%458 = fmul double %456, %457
%459 = call double @llvm.fmuladd.f64(double %454, double %455, double %458)
%460 = load double, double* %32
%461 = fsub double %459, %460
store double %461, double* %37
%462 = load double, double* %35
%463 = load double, double* %31
%464 = load double, double* %36
%465 = load double, double* %30
%466 = fmul double %464, %465
%467 = call double @llvm.fmuladd.f64(double %462, double %463, double %466)
%468 = load double, double* %32
%469 = fadd double %467, %468
store double %469, double* %38
%470 = load double, double* %37
%471 = load double*, double** %17
%472 = load i32, i32* %14
%473 = sext i32 %472 to i64
%474 = getelementptr inbounds double, double* %471, i64 %473
store double %470, double* %474
%475 = load double, double* %38
%476 = load double*, double** %19
%477 = load i32, i32* %15
%478 = sext i32 %477 to i64
%479 = getelementptr inbounds double, double* %476, i64 %478
store double %475, double* %479
%480 = load double*, double** %19
%481 = load i32, i32* %14
%482 = sext i32 %481 to i64
%483 = getelementptr inbounds double, double* %480, i64 %482
store double 0.000000e+00, double* %483
%484 = load double*, double** %17
%485 = load i32, i32* %15
%486 = sext i32 %485 to i64
%487 = getelementptr inbounds double, double* %484, i64 %486
store double 0.000000e+00, double* %487
br label %488
488: ; preds = %453, %170
%489 = load i32, i32* %15
%490 = add nsw i32 %489, 1
store i32 %490, i32* %15
%491 = load i32, i32* %9
%492 = load double*, double** %19
%493 = sext i32 %491 to i64
%494 = getelementptr inbounds double, double* %492, i64 %493
store double* %494, double** %19
%495 = load i32, i32* %9
%496 = load double*, double** %20
%497 = sext i32 %495 to i64
%498 = getelementptr inbounds double, double* %496, i64 %497
store double* %498, double** %20
br label %157
499: ; preds = %157
br label %500
500: ; preds = %499
%501 = load i32, i32* %14
%502 = add nsw i32 %501, 1
store i32 %502, i32* %14
%503 = load i32, i32* %9
%504 = load double*, double** %17
%505 = sext i32 %503 to i64
%506 = getelementptr inbounds double, double* %504, i64 %505
store double* %506, double** %17
%507 = load i32, i32* %9
%508 = load double*, double** %18
%509 = sext i32 %507 to i64
%510 = getelementptr inbounds double, double* %508, i64 %509
store double* %510, double** %18
br label %135
511: ; preds = %135
br label %512
512: ; preds = %511
%513 = load i32, i32* %16
%514 = icmp ne i32 %513, 0
br i1 %514, label %132, label %515
515: ; preds = %512
br label %123
516: ; preds = %123
store i32 0, i32* %11
store i32 0, i32* %13
br label %517
517: ; preds = %531, %516
%518 = load i32, i32* %11
%519 = load i32, i32* %9
%520 = icmp slt i32 %518, %519
br i1 %520, label %521, label %538
521: ; preds = %517
%522 = load double*, double** %6
%523 = load i32, i32* %13
%524 = sext i32 %523 to i64
%525 = getelementptr inbounds double, double* %522, i64 %524
%526 = load double, double* %525
%527 = load double*, double** %8
%528 = load i32, i32* %11
%529 = sext i32 %528 to i64
%530 = getelementptr inbounds double, double* %527, i64 %529
store double %526, double* %530
br label %531
531: ; preds = %521
%532 = load i32, i32* %11
%533 = add nsw i32 %532, 1
store i32 %533, i32* %11
%534 = load i32, i32* %9
%535 = add nsw i32 %534, 1
%536 = load i32, i32* %13
%537 = add nsw i32 %536, %535
store i32 %537, i32* %13
br label %517
538: ; preds = %517
store i32 0, i32* %11
br label %539
539: ; preds = %648, %538
%540 = load i32, i32* %11
%541 = load i32, i32* %9
%542 = icmp slt i32 %540, %541
br i1 %542, label %543, label %651
543: ; preds = %539
%544 = load i32, i32* %11
store i32 %544, i32* %43
%545 = load double*, double** %8
%546 = load i32, i32* %11
%547 = sext i32 %546 to i64
%548 = getelementptr inbounds double, double* %545, i64 %547
%549 = load double, double* %548
%550 = call double @llvm.fabs.f64(double %549)
store double %550, double* %44
%551 = load i32, i32* %11
%552 = add nsw i32 %551, 1
store i32 %552, i32* %12
br label %553
553: ; preds = %582, %543
%554 = load i32, i32* %12
%555 = load i32, i32* %9
%556 = icmp slt i32 %554, %555
br i1 %556, label %557, label %585
557: ; preds = %553
%558 = load double*, double** %8
%559 = load i32, i32* %12
%560 = sext i32 %559 to i64
%561 = getelementptr inbounds double, double* %558, i64 %560
%562 = load double, double* %561
%563 = call double @llvm.fabs.f64(double %562)
store double %563, double* %45
%564 = load double, double* %44
%565 = load double, double* %45
%566 = fcmp olt double %564, %565
br i1 %566, label %567, label %569
567: ; preds = %557
%568 = load i32, i32* %12
br label %571
569: ; preds = %557
%570 = load i32, i32* %43
br label %571
571: ; preds = %569, %567
%572 = phi i32 [ %568, %567 ], [ %570, %569 ]
store i32 %572, i32* %43
%573 = load double, double* %44
%574 = load double, double* %45
%575 = fcmp olt double %573, %574
br i1 %575, label %576, label %578
576: ; preds = %571
%577 = load double, double* %45
br label %580
578: ; preds = %571
%579 = load double, double* %44
br label %580
580: ; preds = %578, %576
%581 = phi double [ %577, %576 ], [ %579, %578 ]
store double %581, double* %44
br label %582
582: ; preds = %580
%583 = load i32, i32* %12
%584 = add nsw i32 %583, 1
store i32 %584, i32* %12
br label %553
585: ; preds = %553
%586 = load i32, i32* %43
%587 = load i32, i32* %11
%588 = icmp ne i32 %586, %587
br i1 %588, label %589, label %647
589: ; preds = %585
%590 = load double*, double** %8
%591 = load i32, i32* %11
%592 = sext i32 %591 to i64
%593 = getelementptr inbounds double, double* %590, i64 %592
%594 = load double, double* %593
store double %594, double* %47
%595 = load double*, double** %8
%596 = load i32, i32* %43
%597 = sext i32 %596 to i64
%598 = getelementptr inbounds double, double* %595, i64 %597
%599 = load double, double* %598
%600 = load double*, double** %8
%601 = load i32, i32* %11
%602 = sext i32 %601 to i64
%603 = getelementptr inbounds double, double* %600, i64 %602
store double %599, double* %603
%604 = load double, double* %47
%605 = load double*, double** %8
%606 = load i32, i32* %43
%607 = sext i32 %606 to i64
%608 = getelementptr inbounds double, double* %605, i64 %607
store double %604, double* %608
store i32 0, i32* %12
%609 = load i32, i32* %11
%610 = load i32, i32* %9
%611 = mul nsw i32 %609, %610
store i32 %611, i32* %13
%612 = load i32, i32* %43
%613 = load i32, i32* %9
%614 = mul nsw i32 %612, %613
store i32 %614, i32* %46
br label %615
615: ; preds = %639, %589
%616 = load i32, i32* %12
%617 = load i32, i32* %9
%618 = icmp slt i32 %616, %617
br i1 %618, label %619, label %646
619: ; preds = %615
%620 = load double*, double** %7
%621 = load i32, i32* %13
%622 = sext i32 %621 to i64
%623 = getelementptr inbounds double, double* %620, i64 %622
%624 = load double, double* %623
store double %624, double* %47
%625 = load double*, double** %7
%626 = load i32, i32* %46
%627 = sext i32 %626 to i64
%628 = getelementptr inbounds double, double* %625, i64 %627
%629 = load double, double* %628
%630 = load double*, double** %7
%631 = load i32, i32* %13
%632 = sext i32 %631 to i64
%633 = getelementptr inbounds double, double* %630, i64 %632
store double %629, double* %633
%634 = load double, double* %47
%635 = load double*, double** %7
%636 = load i32, i32* %46
%637 = sext i32 %636 to i64
%638 = getelementptr inbounds double, double* %635, i64 %637
store double %634, double* %638
br label %639
639: ; preds = %619
%640 = load i32, i32* %12
%641 = add nsw i32 %640, 1
store i32 %641, i32* %12
%642 = load i32, i32* %13
%643 = add nsw i32 %642, 1
store i32 %643, i32* %13
%644 = load i32, i32* %46
%645 = add nsw i32 %644, 1
store i32 %645, i32* %46
br label %615
646: ; preds = %615
br label %647
647: ; preds = %646, %585
br label %648
648: ; preds = %647
%649 = load i32, i32* %11
%650 = add nsw i32 %649, 1
store i32 %650, i32* %11
br label %539
651: ; preds = %539
ret i32 0
}

LLVM IR (-O2):
define i32 @cvJacobiEigens_64d(double* nocapture %0, double* nocapture %1, double* nocapture %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 %623
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 %420, 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 %420, label %444
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, %444, %135
br i1 %9, label %421, label %623
421: ; preds = %420
%422 = zext i32 %3 to i64
%423 = zext i32 %3 to i64
%424 = add i32 %3, -1
%425 = zext i32 %424 to i64
%426 = add nuw nsw i64 %425, 1
%427 = getelementptr double, double* %1, i64 %426
%428 = getelementptr double, double* %1, i64 %426
%429 = zext i32 %424 to i64
%430 = add nuw nsw i64 %429, 1
%431 = and i64 %430, 8589934588
%432 = add nsw i64 %431, -4
%433 = lshr exact i64 %432, 2
%434 = add nuw nsw i64 %433, 1
%435 = icmp ult i32 %424, 3
%436 = and i64 %430, 8589934588
%437 = trunc i64 %436 to i32
%438 = and i64 %434, 1
%439 = icmp eq i64 %432, 0
%440 = and i64 %434, 9223372036854775806
%441 = icmp eq i64 %438, 0
%442 = icmp eq i64 %430, %436
%443 = sub i32 0, %3
br label %468
444: ; preds = %155, %444
%445 = phi i64 [ %466, %444 ], [ %156, %155 ]
%446 = phi i64 [ %465, %444 ], [ %157, %155 ]
%447 = getelementptr inbounds double, double* %0, i64 %445
%448 = load double, double* %447
%449 = getelementptr inbounds double, double* %2, i64 %446
store double %448, double* %449
%450 = add nuw nsw i64 %446, 1
%451 = add nsw i64 %445, %90
%452 = getelementptr inbounds double, double* %0, i64 %451
%453 = load double, double* %452
%454 = getelementptr inbounds double, double* %2, i64 %450
store double %453, double* %454
%455 = add nuw nsw i64 %446, 2
%456 = add nsw i64 %451, %90
%457 = getelementptr inbounds double, double* %0, i64 %456
%458 = load double, double* %457
%459 = getelementptr inbounds double, double* %2, i64 %455
store double %458, double* %459
%460 = add nuw nsw i64 %446, 3
%461 = add nsw i64 %456, %90
%462 = getelementptr inbounds double, double* %0, i64 %461
%463 = load double, double* %462
%464 = getelementptr inbounds double, double* %2, i64 %460
store double %463, double* %464
%465 = add nuw nsw i64 %446, 4
%466 = add nsw i64 %461, %90
%467 = icmp eq i64 %465, %91
br i1 %467, label %420, label %444
468: ; preds = %421, %619
%469 = phi i64 [ 0, %421 ], [ %478, %619 ]
%470 = phi i32 [ 0, %421 ], [ %621, %619 ]
%471 = phi i64 [ 1, %421 ], [ %620, %619 ]
%472 = sext i32 %470 to i64
%473 = getelementptr double, double* %1, i64 %472
%474 = getelementptr double, double* %427, i64 %472
%475 = sext i32 %470 to i64
%476 = getelementptr inbounds double, double* %2, i64 %469
%477 = load double, double* %476
%478 = add nuw nsw i64 %469, 1
%479 = icmp ult i64 %478, %422
%480 = trunc i64 %469 to i32
br i1 %479, label %481, label %496
481: ; preds = %468
%482 = tail call double @llvm.fabs.f64(double %477)
br label %483
483: ; preds = %481, %483
%484 = phi i64 [ %471, %481 ], [ %494, %483 ]
%485 = phi double [ %482, %481 ], [ %493, %483 ]
%486 = phi i32 [ %480, %481 ], [ %492, %483 ]
%487 = getelementptr inbounds double, double* %2, i64 %484
%488 = load double, double* %487
%489 = tail call double @llvm.fabs.f64(double %488)
%490 = fcmp olt double %485, %489
%491 = trunc i64 %484 to i32
%492 = select i1 %490, i32 %491, i32 %486
%493 = select i1 %490, double %489, double %485
%494 = add nuw nsw i64 %484, 1
%495 = icmp eq i64 %494, %423
br i1 %495, label %496, label %483
496: ; preds = %483, %468
%497 = phi i32 [ %480, %468 ], [ %492, %483 ]
%498 = zext i32 %497 to i64
%499 = icmp eq i64 %469, %498
br i1 %499, label %619, label %500
500: ; preds = %496
%501 = sext i32 %497 to i64
%502 = getelementptr inbounds double, double* %2, i64 %501
%503 = load double, double* %502
store double %503, double* %476
store double %477, double* %502
%504 = mul i32 %497, %3
%505 = sext i32 %504 to i64
br i1 %435, label %580, label %506
506: ; preds = %500
%507 = getelementptr double, double* %1, i64 %505
%508 = getelementptr double, double* %428, i64 %505
%509 = icmp ult double* %473, %508
%510 = icmp ult double* %507, %474
%511 = and i1 %509, %510
br i1 %511, label %580, label %512
512: ; preds = %506
%513 = add nsw i64 %436, %475
%514 = add nsw i64 %436, %505
br i1 %439, label %558, label %515
515: ; preds = %512, %515
%516 = phi i64 [ %555, %515 ], [ 0, %512 ]
%517 = phi i64 [ %556, %515 ], [ 0, %512 ]
%518 = add i64 %516, %475
%519 = add i64 %516, %505
%520 = getelementptr inbounds double, double* %1, i64 %518
%521 = bitcast double* %520 to <2 x double>*
%522 = load <2 x double>, <2 x double>* %521
%523 = getelementptr inbounds double, double* %520, i64 2
%524 = bitcast double* %523 to <2 x double>*
%525 = load <2 x double>, <2 x double>* %524
%526 = getelementptr inbounds double, double* %1, i64 %519
%527 = bitcast double* %526 to <2 x double>*
%528 = load <2 x double>, <2 x double>* %527
%529 = getelementptr inbounds double, double* %526, i64 2
%530 = bitcast double* %529 to <2 x double>*
%531 = load <2 x double>, <2 x double>* %530
%532 = bitcast double* %520 to <2 x double>*
store <2 x double> %528, <2 x double>* %532
%533 = bitcast double* %523 to <2 x double>*
store <2 x double> %531, <2 x double>* %533
%534 = bitcast double* %526 to <2 x double>*
store <2 x double> %522, <2 x double>* %534
%535 = bitcast double* %529 to <2 x double>*
store <2 x double> %525, <2 x double>* %535
%536 = or i64 %516, 4
%537 = add i64 %536, %475
%538 = add i64 %536, %505
%539 = getelementptr inbounds double, double* %1, i64 %537
%540 = bitcast double* %539 to <2 x double>*
%541 = load <2 x double>, <2 x double>* %540
%542 = getelementptr inbounds double, double* %539, i64 2
%543 = bitcast double* %542 to <2 x double>*
%544 = load <2 x double>, <2 x double>* %543
%545 = getelementptr inbounds double, double* %1, i64 %538
%546 = bitcast double* %545 to <2 x double>*
%547 = load <2 x double>, <2 x double>* %546
%548 = getelementptr inbounds double, double* %545, i64 2
%549 = bitcast double* %548 to <2 x double>*
%550 = load <2 x double>, <2 x double>* %549
%551 = bitcast double* %539 to <2 x double>*
store <2 x double> %547, <2 x double>* %551
%552 = bitcast double* %542 to <2 x double>*
store <2 x double> %550, <2 x double>* %552
%553 = bitcast double* %545 to <2 x double>*
store <2 x double> %541, <2 x double>* %553
%554 = bitcast double* %548 to <2 x double>*
store <2 x double> %544, <2 x double>* %554
%555 = add nuw i64 %516, 8
%556 = add i64 %517, 2
%557 = icmp eq i64 %556, %440
br i1 %557, label %558, label %515
558: ; preds = %515, %512
%559 = phi i64 [ 0, %512 ], [ %555, %515 ]
br i1 %441, label %579, label %560
560: ; preds = %558
%561 = add i64 %559, %475
%562 = add i64 %559, %505
%563 = getelementptr inbounds double, double* %1, i64 %561
%564 = bitcast double* %563 to <2 x double>*
%565 = load <2 x double>, <2 x double>* %564
%566 = getelementptr inbounds double, double* %563, i64 2
%567 = bitcast double* %566 to <2 x double>*
%568 = load <2 x double>, <2 x double>* %567
%569 = getelementptr inbounds double, double* %1, i64 %562
%570 = bitcast double* %569 to <2 x double>*
%571 = load <2 x double>, <2 x double>* %570
%572 = getelementptr inbounds double, double* %569, i64 2
%573 = bitcast double* %572 to <2 x double>*
%574 = load <2 x double>, <2 x double>* %573
%575 = bitcast double* %563 to <2 x double>*
store <2 x double> %571, <2 x double>* %575
%576 = bitcast double* %566 to <2 x double>*
store <2 x double> %574, <2 x double>* %576
%577 = bitcast double* %569 to <2 x double>*
store <2 x double> %565, <2 x double>* %577
%578 = bitcast double* %572 to <2 x double>*
store <2 x double> %568, <2 x double>* %578
br label %579
579: ; preds = %558, %560
br i1 %442, label %619, label %580
580: ; preds = %506, %500, %579
%581 = phi i64 [ %475, %506 ], [ %475, %500 ], [ %513, %579 ]
%582 = phi i64 [ %505, %506 ], [ %505, %500 ], [ %514, %579 ]
%583 = phi i32 [ 0, %506 ], [ 0, %500 ], [ %437, %579 ]
%584 = sub i32 %3, %583
%585 = xor i32 %583, -1
%586 = and i32 %584, 1
%587 = icmp eq i32 %586, 0
br i1 %587, label %596, label %588
588: ; preds = %580
%589 = getelementptr inbounds double, double* %1, i64 %581
%590 = load double, double* %589
%591 = getelementptr inbounds double, double* %1, i64 %582
%592 = load double, double* %591
store double %592, double* %589
store double %590, double* %591
%593 = add nuw nsw i32 %583, 1
%594 = add nsw i64 %581, 1
%595 = add nsw i64 %582, 1
br label %596
596: ; preds = %588, %580
%597 = phi i64 [ %581, %580 ], [ %594, %588 ]
%598 = phi i64 [ %582, %580 ], [ %595, %588 ]
%599 = phi i32 [ %583, %580 ], [ %593, %588 ]
%600 = icmp eq i32 %585, %443
br i1 %600, label %619, label %601
601: ; preds = %596, %601
%602 = phi i64 [ %616, %601 ], [ %597, %596 ]
%603 = phi i64 [ %617, %601 ], [ %598, %596 ]
%604 = phi i32 [ %615, %601 ], [ %599, %596 ]
%605 = getelementptr inbounds double, double* %1, i64 %602
%606 = load double, double* %605
%607 = getelementptr inbounds double, double* %1, i64 %603
%608 = load double, double* %607
store double %608, double* %605
store double %606, double* %607
%609 = add nsw i64 %602, 1
%610 = add nsw i64 %603, 1
%611 = getelementptr inbounds double, double* %1, i64 %609
%612 = load double, double* %611
%613 = getelementptr inbounds double, double* %1, i64 %610
%614 = load double, double* %613
store double %614, double* %611
store double %612, double* %613
%615 = add nuw nsw i32 %604, 2
%616 = add nsw i64 %602, 2
%617 = add nsw i64 %603, 2
%618 = icmp eq i32 %615, %3
br i1 %618, label %619, label %601
619: ; preds = %596, %601, %579, %496
%620 = add nuw nsw i64 %471, 1
%621 = add i32 %470, %3
%622 = icmp eq i64 %478, %423
br i1 %622, label %623, label %468
623: ; preds = %619, %87, %420
ret i32 0
}