#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;
  int j;
  int k;
  int p;
  int q;
  int ind;
  double *A1;
  double *V1;
  double *A2;
  double *V2;
  double Amax;
  double anorm;
  double ax;
  double deps;
  double Am;
  double x;
  double y;
  double c;
  double s;
  double c2;
  double s2;
  double a;
  double *A3;
  double Apq;
  double App;
  double Aqq;
  double App2;
  double Aqq2;
  double Aip;
  double Aiq;
  double Vpi;
  double Vqi;
  double tmp;
  double tmp___0;
  double tmp___1;
  double tmp___2;
  double tmp___3;
  int m;
  double Em;
  double tmp___4;
  double Ej;
  double tmp___5;
  int l;
  double b;
  {
    A1 = A;
    V1 = V;
    A2 = A;
    V2 = V;
    Amax = 0.0;
    anorm = 0.0;
    if (eps < 1.0e-15) {
      eps = 1.0e-15;
    }
    deps = eps / (double)n;
    i = 0;
    while (i < n) {
      j = 0;
      while (j < i) {
        Am = *(A1 + j);
        anorm += Am * Am;
        j++;
      }
      j = 0;
      while (j < n) {
        *(V1 + j) = 0.0;
        j++;
      }
      *(V1 + i) = 1.0;
      i++;
      V1 += n;
      A1 += n;
    }
    anorm = sqrt(anorm + anorm);
    ax = (anorm * eps) / (double)n;
    Amax = anorm;
    while (Amax > ax) {
      Amax /= (double)n;
      while (1) {
        ind = 0;
        A1 = A;
        V1 = V;
        p = 0;
        while (p < n - 1) {
          A2 = A + n * (p + 1);
          V2 = V + n * (p + 1);
          q = p + 1;
          while (q < n) {
            tmp = fabs(*(A1 + q));
            if (tmp < Amax) {
              goto __Cont;
            }
            Apq = *(A1 + q);
            ind = 1;
            App = *(A1 + p);
            Aqq = *(A2 + q);
            y = 5.0e-1 * (App - Aqq);
            tmp___0 = sqrt(Apq * Apq + y * y);
            x = -Apq / tmp___0;
            if (y < 0.0) {
              x = -x;
            }
            tmp___1 = sqrt(1.0 - x * x);
            tmp___2 = sqrt(2.0 * (1.0 + tmp___1));
            s = x / tmp___2;
            s2 = s * s;
            c = sqrt(1.0 - s2);
            c2 = c * c;
            a = ((2.0 * Apq) * c) * s;
            A3 = A;
            i = 0;
            while (i < p) {
              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;
              i++;
              A3 += n;
            }
            while (i < q) {
              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;
              i++;
              A3 += n;
            }
            while (i < n) {
              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;
              i++;
            }
            App2 = (App * c2 + Aqq * s2) - a;
            Aqq2 = (App * s2 + Aqq * c2) + a;
            *(A1 + p) = App2;
            *(A2 + q) = Aqq2;
            tmp___3 = 0.0;
            *(A2 + p) = tmp___3;
            *(A1 + q) = tmp___3;
          __Cont:
            q++;
            A2 += n;
            V2 += n;
          }
          p++;
          A1 += n;
          V1 += n;
        }
        if (!ind) {
          break;
        }
      }
    }
    i = 0;
    k = 0;
    while (i < n) {
      *(E + i) = *(A + k);
      i++;
      k += n + 1;
    }
    i = 0;
    while (i < n) {
      m = i;
      tmp___4 = fabs(*(E + i));
      Em = tmp___4;
      j = i + 1;
      while (j < n) {
        tmp___5 = fabs(*(E + j));
        Ej = tmp___5;
        if (Em < Ej) {
          m = j;
        } else {
          m = m;
        }
        if (Em < Ej) {
          Em = Ej;
        } else {
          Em = Em;
        }
        j++;
      }
      if (m != i) {
        b = *(E + i);
        *(E + i) = *(E + m);
        *(E + m) = b;
        j = 0;
        k = i * n;
        l = m * n;
        while (j < n) {
          b = *(V + k);
          *(V + k) = *(V + l);
          *(V + l) = b;
          j++;
          k++;
          l++;
        }
      }
      i++;
    }
    return (0);
  }
}


x86 assembly (clang, -O0):
<cvJacobiEigens_64d>:
push   %rbp
mov    %rsp,%rbp
sub    $0x170,%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    1b9c <cvJacobiEigens_64d+0xa8c>
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    1b83 <cvJacobiEigens_64d+0xa73>
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    1b4b <cvJacobiEigens_64d+0xa3b>
mov    -0x48(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xcb8(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
movsd  -0x118(%rbp),%xmm1
ff
movsd  -0x68(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1390 <cvJacobiEigens_64d+0x280>
jmp    1b13 <cvJacobiEigens_64d+0xa03>
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  0xc1a(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%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>
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
divsd  -0x120(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
xorps  %xmm0,%xmm0
ucomisd -0x98(%rbp),%xmm0
ff
jbe    1496 <cvJacobiEigens_64d+0x386>
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  -0x90(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm1,%xmm0
movsd  0xb4f(%rip),%xmm1
addsd  %xmm1,%xmm0
call   1030 <sqrt@plt>
movsd  %xmm0,-0x128(%rbp)
ff
movsd  0xb36(%rip),%xmm1
addsd  -0x128(%rbp),%xmm1
ff
movsd  0xb1e(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <sqrt@plt>
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
divsd  -0x130(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
mulsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  0xadd(%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  0xaa0(%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    1739 <cvJacobiEigens_64d+0x629>
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    15a2 <cvJacobiEigens_64d+0x492>
jmp    173e <cvJacobiEigens_64d+0x62e>
mov    -0x2c(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    18cf <cvJacobiEigens_64d+0x7bf>
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    173e <cvJacobiEigens_64d+0x62e>
jmp    18d4 <cvJacobiEigens_64d+0x7c4>
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1a44 <cvJacobiEigens_64d+0x934>
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    18d4 <cvJacobiEigens_64d+0x7c4>
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)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0x138(%rbp),%xmm0
ff
mov    -0x58(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x138(%rbp),%xmm0
ff
mov    -0x48(%rbp),%rax
movslq -0x3c(%rbp),%rcx
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>
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>
cmpl   $0x0,-0x40(%rbp)
jne    1b92 <cvJacobiEigens_64d+0xa82>
jmp    1b97 <cvJacobiEigens_64d+0xa87>
jmp    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    1bea <cvJacobiEigens_64d+0xada>
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    1baa <cvJacobiEigens_64d+0xa9a>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1e05 <cvJacobiEigens_64d+0xcf5>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x13c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x406(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
movsd  -0x150(%rbp),%xmm0
ff
movsd  %xmm0,-0x148(%rbp)
ff
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1cfc <cvJacobiEigens_64d+0xbec>
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x3c1(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
movsd  -0x160(%rbp),%xmm0
ff
movsd  %xmm0,-0x158(%rbp)
ff
movsd  -0x148(%rbp),%xmm1
ff
movsd  -0x158(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    1ca3 <cvJacobiEigens_64d+0xb93>
mov    -0x30(%rbp),%eax
mov    %eax,-0x13c(%rbp)
jmp    1caf <cvJacobiEigens_64d+0xb9f>
mov    -0x13c(%rbp),%eax
mov    %eax,-0x13c(%rbp)
movsd  -0x148(%rbp),%xmm1
ff
movsd  -0x158(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    1cde <cvJacobiEigens_64d+0xbce>
movsd  -0x158(%rbp),%xmm0
ff
movsd  %xmm0,-0x148(%rbp)
ff
jmp    1cee <cvJacobiEigens_64d+0xbde>
movsd  -0x148(%rbp),%xmm0
ff
movsd  %xmm0,-0x148(%rbp)
ff
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1c3f <cvJacobiEigens_64d+0xb2f>
mov    -0x13c(%rbp),%eax
cmp    -0x2c(%rbp),%eax
je     1df7 <cvJacobiEigens_64d+0xce7>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x170(%rbp)
ff
mov    -0x18(%rbp),%rax
movslq -0x13c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x170(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x13c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x30(%rbp)
mov    -0x2c(%rbp),%eax
imul   -0x1c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x13c(%rbp),%eax
imul   -0x1c(%rbp),%eax
mov    %eax,-0x164(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1df2 <cvJacobiEigens_64d+0xce2>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x170(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x164(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x170(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x164(%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    -0x164(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x164(%rbp)
jmp    1d76 <cvJacobiEigens_64d+0xc66>
jmp    1df7 <cvJacobiEigens_64d+0xce7>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1bf1 <cvJacobiEigens_64d+0xae1>
xor    %eax,%eax
add    $0x170,%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 double
%44 = alloca double
%45 = alloca double
%46 = alloca double
%47 = alloca double
%48 = alloca i32
%49 = alloca double
%50 = alloca double
%51 = alloca double
%52 = alloca double
%53 = alloca i32
%54 = 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
%55 = load double*, double** %6
store double* %55, double** %17
%56 = load double*, double** %7
store double* %56, double** %18
%57 = load double*, double** %6
store double* %57, double** %19
%58 = load double*, double** %7
store double* %58, double** %20
store double 0.000000e+00, double* %21
store double 0.000000e+00, double* %22
%59 = load double, double* %10
%60 = fcmp olt double %59, 1.000000e-15
br i1 %60, label %61, label %62
61: ; preds = %5
store double 1.000000e-15, double* %10
br label %62
62: ; preds = %61, %5
%63 = load double, double* %10
%64 = load i32, i32* %9
%65 = sitofp i32 %64 to double
%66 = fdiv double %63, %65
store double %66, double* %24
store i32 0, i32* %11
br label %67
67: ; preds = %100, %62
%68 = load i32, i32* %11
%69 = load i32, i32* %9
%70 = icmp slt i32 %68, %69
br i1 %70, label %71, label %115
71: ; preds = %67
store i32 0, i32* %12
br label %72
72: ; preds = %76, %71
%73 = load i32, i32* %12
%74 = load i32, i32* %11
%75 = icmp slt i32 %73, %74
br i1 %75, label %76, label %88
76: ; preds = %72
%77 = load double*, double** %17
%78 = load i32, i32* %12
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds double, double* %77, i64 %79
%81 = load double, double* %80
store double %81, double* %25
%82 = load double, double* %25
%83 = load double, double* %25
%84 = load double, double* %22
%85 = call double @llvm.fmuladd.f64(double %82, double %83, double %84)
store double %85, double* %22
%86 = load i32, i32* %12
%87 = add nsw i32 %86, 1
store i32 %87, i32* %12
br label %72
88: ; preds = %72
store i32 0, i32* %12
br label %89
89: ; preds = %93, %88
%90 = load i32, i32* %12
%91 = load i32, i32* %9
%92 = icmp slt i32 %90, %91
br i1 %92, label %93, label %100
93: ; preds = %89
%94 = load double*, double** %18
%95 = load i32, i32* %12
%96 = sext i32 %95 to i64
%97 = getelementptr inbounds double, double* %94, i64 %96
store double 0.000000e+00, double* %97
%98 = load i32, i32* %12
%99 = add nsw i32 %98, 1
store i32 %99, i32* %12
br label %89
100: ; preds = %89
%101 = load double*, double** %18
%102 = load i32, i32* %11
%103 = sext i32 %102 to i64
%104 = getelementptr inbounds double, double* %101, i64 %103
store double 1.000000e+00, double* %104
%105 = load i32, i32* %11
%106 = add nsw i32 %105, 1
store i32 %106, i32* %11
%107 = load i32, i32* %9
%108 = load double*, double** %18
%109 = sext i32 %107 to i64
%110 = getelementptr inbounds double, double* %108, i64 %109
store double* %110, double** %18
%111 = load i32, i32* %9
%112 = load double*, double** %17
%113 = sext i32 %111 to i64
%114 = getelementptr inbounds double, double* %112, i64 %113
store double* %114, double** %17
br label %67
115: ; preds = %67
%116 = load double, double* %22
%117 = load double, double* %22
%118 = fadd double %116, %117
%119 = call double @sqrt(double %118)
store double %119, double* %22
%120 = load double, double* %22
%121 = load double, double* %10
%122 = fmul double %120, %121
%123 = load i32, i32* %9
%124 = sitofp i32 %123 to double
%125 = fdiv double %122, %124
store double %125, double* %23
%126 = load double, double* %22
store double %126, double* %21
br label %127
127: ; preds = %522, %115
%128 = load double, double* %21
%129 = load double, double* %23
%130 = fcmp ogt double %128, %129
br i1 %130, label %131, label %523
131: ; preds = %127
%132 = load i32, i32* %9
%133 = sitofp i32 %132 to double
%134 = load double, double* %21
%135 = fdiv double %134, %133
store double %135, double* %21
br label %136
136: ; preds = %131, %521
store i32 0, i32* %16
%137 = load double*, double** %6
store double* %137, double** %17
%138 = load double*, double** %7
store double* %138, double** %18
store i32 0, i32* %14
br label %139
139: ; preds = %506, %136
%140 = load i32, i32* %14
%141 = load i32, i32* %9
%142 = sub nsw i32 %141, 1
%143 = icmp slt i32 %140, %142
br i1 %143, label %144, label %517
144: ; preds = %139
%145 = load double*, double** %6
%146 = load i32, i32* %9
%147 = load i32, i32* %14
%148 = add nsw i32 %147, 1
%149 = mul nsw i32 %146, %148
%150 = sext i32 %149 to i64
%151 = getelementptr inbounds double, double* %145, i64 %150
store double* %151, double** %19
%152 = load double*, double** %7
%153 = load i32, i32* %9
%154 = load i32, i32* %14
%155 = add nsw i32 %154, 1
%156 = mul nsw i32 %153, %155
%157 = sext i32 %156 to i64
%158 = getelementptr inbounds double, double* %152, i64 %157
store double* %158, double** %20
%159 = load i32, i32* %14
%160 = add nsw i32 %159, 1
store i32 %160, i32* %15
br label %161
161: ; preds = %495, %144
%162 = load i32, i32* %15
%163 = load i32, i32* %9
%164 = icmp slt i32 %162, %163
br i1 %164, label %165, label %506
165: ; preds = %161
%166 = load double*, double** %17
%167 = load i32, i32* %15
%168 = sext i32 %167 to i64
%169 = getelementptr inbounds double, double* %166, i64 %168
%170 = load double, double* %169
%171 = call double @llvm.fabs.f64(double %170)
store double %171, double* %43
%172 = load double, double* %43
%173 = load double, double* %21
%174 = fcmp olt double %172, %173
br i1 %174, label %175, label %176
175: ; preds = %165
br label %495
176: ; preds = %165
%177 = load double*, double** %17
%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* %34
store i32 1, i32* %16
%182 = load double*, double** %17
%183 = load i32, i32* %14
%184 = sext i32 %183 to i64
%185 = getelementptr inbounds double, double* %182, i64 %184
%186 = load double, double* %185
store double %186, double* %35
%187 = load double*, double** %19
%188 = load i32, i32* %15
%189 = sext i32 %188 to i64
%190 = getelementptr inbounds double, double* %187, i64 %189
%191 = load double, double* %190
store double %191, double* %36
%192 = load double, double* %35
%193 = load double, double* %36
%194 = fsub double %192, %193
%195 = fmul double 5.000000e-01, %194
store double %195, double* %27
%196 = load double, double* %34
%197 = load double, double* %34
%198 = load double, double* %27
%199 = load double, double* %27
%200 = fmul double %198, %199
%201 = call double @llvm.fmuladd.f64(double %196, double %197, double %200)
%202 = call double @sqrt(double %201)
store double %202, double* %44
%203 = load double, double* %34
%204 = fneg double %203
%205 = load double, double* %44
%206 = fdiv double %204, %205
store double %206, double* %26
%207 = load double, double* %27
%208 = fcmp olt double %207, 0.000000e+00
br i1 %208, label %209, label %212
209: ; preds = %176
%210 = load double, double* %26
%211 = fneg double %210
store double %211, double* %26
br label %212
212: ; preds = %209, %176
%213 = load double, double* %26
%214 = load double, double* %26
%215 = fneg double %213
%216 = call double @llvm.fmuladd.f64(double %215, double %214, double 1.000000e+00)
%217 = call double @sqrt(double %216)
store double %217, double* %45
%218 = load double, double* %45
%219 = fadd double 1.000000e+00, %218
%220 = fmul double 2.000000e+00, %219
%221 = call double @sqrt(double %220)
store double %221, double* %46
%222 = load double, double* %26
%223 = load double, double* %46
%224 = fdiv double %222, %223
store double %224, double* %29
%225 = load double, double* %29
%226 = load double, double* %29
%227 = fmul double %225, %226
store double %227, double* %31
%228 = load double, double* %31
%229 = fsub double 1.000000e+00, %228
%230 = call double @sqrt(double %229)
store double %230, double* %28
%231 = load double, double* %28
%232 = load double, double* %28
%233 = fmul double %231, %232
store double %233, double* %30
%234 = load double, double* %34
%235 = fmul double 2.000000e+00, %234
%236 = load double, double* %28
%237 = fmul double %235, %236
%238 = load double, double* %29
%239 = fmul double %237, %238
store double %239, double* %32
%240 = load double*, double** %6
store double* %240, double** %33
store i32 0, i32* %11
br label %241
241: ; preds = %245, %212
%242 = load i32, i32* %11
%243 = load i32, i32* %14
%244 = icmp slt i32 %242, %243
br i1 %244, label %245, label %314
245: ; preds = %241
%246 = load double*, double** %33
%247 = load i32, i32* %14
%248 = sext i32 %247 to i64
%249 = getelementptr inbounds double, double* %246, i64 %248
%250 = load double, double* %249
store double %250, double* %39
%251 = load double*, double** %33
%252 = load i32, i32* %15
%253 = sext i32 %252 to i64
%254 = getelementptr inbounds double, double* %251, i64 %253
%255 = load double, double* %254
store double %255, double* %40
%256 = load double*, double** %18
%257 = load i32, i32* %11
%258 = sext i32 %257 to i64
%259 = getelementptr inbounds double, double* %256, i64 %258
%260 = load double, double* %259
store double %260, double* %41
%261 = load double*, double** %20
%262 = load i32, i32* %11
%263 = sext i32 %262 to i64
%264 = getelementptr inbounds double, double* %261, i64 %263
%265 = load double, double* %264
store double %265, double* %42
%266 = load double, double* %39
%267 = load double, double* %28
%268 = load double, double* %40
%269 = load double, double* %29
%270 = fmul double %268, %269
%271 = fneg double %270
%272 = call double @llvm.fmuladd.f64(double %266, double %267, double %271)
%273 = load double*, double** %33
%274 = load i32, i32* %14
%275 = sext i32 %274 to i64
%276 = getelementptr inbounds double, double* %273, i64 %275
store double %272, double* %276
%277 = load double, double* %40
%278 = load double, double* %28
%279 = load double, double* %39
%280 = load double, double* %29
%281 = fmul double %279, %280
%282 = call double @llvm.fmuladd.f64(double %277, double %278, double %281)
%283 = load double*, double** %33
%284 = load i32, i32* %15
%285 = sext i32 %284 to i64
%286 = getelementptr inbounds double, double* %283, i64 %285
store double %282, double* %286
%287 = load double, double* %41
%288 = load double, double* %28
%289 = load double, double* %42
%290 = load double, double* %29
%291 = fmul double %289, %290
%292 = fneg double %291
%293 = call double @llvm.fmuladd.f64(double %287, double %288, double %292)
%294 = load double*, double** %18
%295 = load i32, i32* %11
%296 = sext i32 %295 to i64
%297 = getelementptr inbounds double, double* %294, i64 %296
store double %293, double* %297
%298 = load double, double* %42
%299 = load double, double* %28
%300 = load double, double* %41
%301 = load double, double* %29
%302 = fmul double %300, %301
%303 = call double @llvm.fmuladd.f64(double %298, double %299, double %302)
%304 = load double*, double** %20
%305 = load i32, i32* %11
%306 = sext i32 %305 to i64
%307 = getelementptr inbounds double, double* %304, i64 %306
store double %303, double* %307
%308 = load i32, i32* %11
%309 = add nsw i32 %308, 1
store i32 %309, i32* %11
%310 = load i32, i32* %9
%311 = load double*, double** %33
%312 = sext i32 %310 to i64
%313 = getelementptr inbounds double, double* %311, i64 %312
store double* %313, double** %33
br label %241
314: ; preds = %241
br label %315
315: ; preds = %319, %314
%316 = load i32, i32* %11
%317 = load i32, i32* %15
%318 = icmp slt i32 %316, %317
br i1 %318, label %319, label %388
319: ; preds = %315
%320 = load double*, double** %17
%321 = load i32, i32* %11
%322 = sext i32 %321 to i64
%323 = getelementptr inbounds double, double* %320, i64 %322
%324 = load double, double* %323
store double %324, double* %39
%325 = load double*, double** %33
%326 = load i32, i32* %15
%327 = sext i32 %326 to i64
%328 = getelementptr inbounds double, double* %325, i64 %327
%329 = load double, double* %328
store double %329, double* %40
%330 = load double*, double** %18
%331 = load i32, i32* %11
%332 = sext i32 %331 to i64
%333 = getelementptr inbounds double, double* %330, i64 %332
%334 = load double, double* %333
store double %334, double* %41
%335 = load double*, double** %20
%336 = load i32, i32* %11
%337 = sext i32 %336 to i64
%338 = getelementptr inbounds double, double* %335, i64 %337
%339 = load double, double* %338
store double %339, double* %42
%340 = load double, double* %39
%341 = load double, double* %28
%342 = load double, double* %40
%343 = load double, double* %29
%344 = fmul double %342, %343
%345 = fneg double %344
%346 = call double @llvm.fmuladd.f64(double %340, double %341, double %345)
%347 = load double*, double** %17
%348 = load i32, i32* %11
%349 = sext i32 %348 to i64
%350 = getelementptr inbounds double, double* %347, i64 %349
store double %346, double* %350
%351 = load double, double* %40
%352 = load double, double* %28
%353 = load double, double* %39
%354 = load double, double* %29
%355 = fmul double %353, %354
%356 = call double @llvm.fmuladd.f64(double %351, double %352, double %355)
%357 = load double*, double** %33
%358 = load i32, i32* %15
%359 = sext i32 %358 to i64
%360 = getelementptr inbounds double, double* %357, i64 %359
store double %356, double* %360
%361 = load double, double* %41
%362 = load double, double* %28
%363 = load double, double* %42
%364 = load double, double* %29
%365 = fmul double %363, %364
%366 = fneg double %365
%367 = call double @llvm.fmuladd.f64(double %361, double %362, double %366)
%368 = load double*, double** %18
%369 = load i32, i32* %11
%370 = sext i32 %369 to i64
%371 = getelementptr inbounds double, double* %368, i64 %370
store double %367, double* %371
%372 = load double, double* %42
%373 = load double, double* %28
%374 = load double, double* %41
%375 = load double, double* %29
%376 = fmul double %374, %375
%377 = call double @llvm.fmuladd.f64(double %372, double %373, double %376)
%378 = load double*, double** %20
%379 = load i32, i32* %11
%380 = sext i32 %379 to i64
%381 = getelementptr inbounds double, double* %378, i64 %380
store double %377, double* %381
%382 = load i32, i32* %11
%383 = add nsw i32 %382, 1
store i32 %383, i32* %11
%384 = load i32, i32* %9
%385 = load double*, double** %33
%386 = sext i32 %384 to i64
%387 = getelementptr inbounds double, double* %385, i64 %386
store double* %387, double** %33
br label %315
388: ; preds = %315
br label %389
389: ; preds = %393, %388
%390 = load i32, i32* %11
%391 = load i32, i32* %9
%392 = icmp slt i32 %390, %391
br i1 %392, label %393, label %458
393: ; preds = %389
%394 = load double*, double** %17
%395 = load i32, i32* %11
%396 = sext i32 %395 to i64
%397 = getelementptr inbounds double, double* %394, i64 %396
%398 = load double, double* %397
store double %398, double* %39
%399 = load double*, double** %19
%400 = load i32, i32* %11
%401 = sext i32 %400 to i64
%402 = getelementptr inbounds double, double* %399, i64 %401
%403 = load double, double* %402
store double %403, double* %40
%404 = load double*, double** %18
%405 = load i32, i32* %11
%406 = sext i32 %405 to i64
%407 = getelementptr inbounds double, double* %404, i64 %406
%408 = load double, double* %407
store double %408, double* %41
%409 = load double*, double** %20
%410 = load i32, i32* %11
%411 = sext i32 %410 to i64
%412 = getelementptr inbounds double, double* %409, i64 %411
%413 = load double, double* %412
store double %413, double* %42
%414 = load double, double* %39
%415 = load double, double* %28
%416 = load double, double* %40
%417 = load double, double* %29
%418 = fmul double %416, %417
%419 = fneg double %418
%420 = call double @llvm.fmuladd.f64(double %414, double %415, double %419)
%421 = load double*, double** %17
%422 = load i32, i32* %11
%423 = sext i32 %422 to i64
%424 = getelementptr inbounds double, double* %421, i64 %423
store double %420, double* %424
%425 = load double, double* %40
%426 = load double, double* %28
%427 = load double, double* %39
%428 = load double, double* %29
%429 = fmul double %427, %428
%430 = call double @llvm.fmuladd.f64(double %425, double %426, double %429)
%431 = load double*, double** %19
%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* %41
%436 = load double, double* %28
%437 = load double, double* %42
%438 = load double, double* %29
%439 = fmul double %437, %438
%440 = fneg double %439
%441 = call double @llvm.fmuladd.f64(double %435, double %436, double %440)
%442 = load double*, double** %18
%443 = load i32, i32* %11
%444 = sext i32 %443 to i64
%445 = getelementptr inbounds double, double* %442, i64 %444
store double %441, double* %445
%446 = load double, double* %42
%447 = load double, double* %28
%448 = load double, double* %41
%449 = load double, double* %29
%450 = fmul double %448, %449
%451 = call double @llvm.fmuladd.f64(double %446, double %447, double %450)
%452 = load double*, double** %20
%453 = load i32, i32* %11
%454 = sext i32 %453 to i64
%455 = getelementptr inbounds double, double* %452, i64 %454
store double %451, double* %455
%456 = load i32, i32* %11
%457 = add nsw i32 %456, 1
store i32 %457, i32* %11
br label %389
458: ; preds = %389
%459 = load double, double* %35
%460 = load double, double* %30
%461 = load double, double* %36
%462 = load double, double* %31
%463 = fmul double %461, %462
%464 = call double @llvm.fmuladd.f64(double %459, double %460, double %463)
%465 = load double, double* %32
%466 = fsub double %464, %465
store double %466, double* %37
%467 = load double, double* %35
%468 = load double, double* %31
%469 = load double, double* %36
%470 = load double, double* %30
%471 = fmul double %469, %470
%472 = call double @llvm.fmuladd.f64(double %467, double %468, double %471)
%473 = load double, double* %32
%474 = fadd double %472, %473
store double %474, double* %38
%475 = load double, double* %37
%476 = load double*, double** %17
%477 = load i32, i32* %14
%478 = sext i32 %477 to i64
%479 = getelementptr inbounds double, double* %476, i64 %478
store double %475, double* %479
%480 = load double, double* %38
%481 = load double*, double** %19
%482 = load i32, i32* %15
%483 = sext i32 %482 to i64
%484 = getelementptr inbounds double, double* %481, i64 %483
store double %480, double* %484
store double 0.000000e+00, double* %47
%485 = load double, double* %47
%486 = load double*, double** %19
%487 = load i32, i32* %14
%488 = sext i32 %487 to i64
%489 = getelementptr inbounds double, double* %486, i64 %488
store double %485, double* %489
%490 = load double, double* %47
%491 = load double*, double** %17
%492 = load i32, i32* %15
%493 = sext i32 %492 to i64
%494 = getelementptr inbounds double, double* %491, i64 %493
store double %490, double* %494
br label %495
495: ; preds = %458, %175
%496 = load i32, i32* %15
%497 = add nsw i32 %496, 1
store i32 %497, i32* %15
%498 = load i32, i32* %9
%499 = load double*, double** %19
%500 = sext i32 %498 to i64
%501 = getelementptr inbounds double, double* %499, i64 %500
store double* %501, double** %19
%502 = load i32, i32* %9
%503 = load double*, double** %20
%504 = sext i32 %502 to i64
%505 = getelementptr inbounds double, double* %503, i64 %504
store double* %505, double** %20
br label %161
506: ; preds = %161
%507 = load i32, i32* %14
%508 = add nsw i32 %507, 1
store i32 %508, i32* %14
%509 = load i32, i32* %9
%510 = load double*, double** %17
%511 = sext i32 %509 to i64
%512 = getelementptr inbounds double, double* %510, i64 %511
store double* %512, double** %17
%513 = load i32, i32* %9
%514 = load double*, double** %18
%515 = sext i32 %513 to i64
%516 = getelementptr inbounds double, double* %514, i64 %515
store double* %516, double** %18
br label %139
517: ; preds = %139
%518 = load i32, i32* %16
%519 = icmp ne i32 %518, 0
br i1 %519, label %521, label %520
520: ; preds = %517
br label %522
521: ; preds = %517
br label %136
522: ; preds = %520
br label %127
523: ; preds = %127
store i32 0, i32* %11
store i32 0, i32* %13
br label %524
524: ; preds = %528, %523
%525 = load i32, i32* %11
%526 = load i32, i32* %9
%527 = icmp slt i32 %525, %526
br i1 %527, label %528, label %544
528: ; preds = %524
%529 = load double*, double** %6
%530 = load i32, i32* %13
%531 = sext i32 %530 to i64
%532 = getelementptr inbounds double, double* %529, i64 %531
%533 = load double, double* %532
%534 = load double*, double** %8
%535 = load i32, i32* %11
%536 = sext i32 %535 to i64
%537 = getelementptr inbounds double, double* %534, i64 %536
store double %533, double* %537
%538 = load i32, i32* %11
%539 = add nsw i32 %538, 1
store i32 %539, i32* %11
%540 = load i32, i32* %9
%541 = add nsw i32 %540, 1
%542 = load i32, i32* %13
%543 = add nsw i32 %542, %541
store i32 %543, i32* %13
br label %524
544: ; preds = %524
store i32 0, i32* %11
br label %545
545: ; preds = %651, %544
%546 = load i32, i32* %11
%547 = load i32, i32* %9
%548 = icmp slt i32 %546, %547
br i1 %548, label %549, label %654
549: ; preds = %545
%550 = load i32, i32* %11
store i32 %550, i32* %48
%551 = load double*, double** %8
%552 = load i32, i32* %11
%553 = sext i32 %552 to i64
%554 = getelementptr inbounds double, double* %551, i64 %553
%555 = load double, double* %554
%556 = call double @llvm.fabs.f64(double %555)
store double %556, double* %50
%557 = load double, double* %50
store double %557, double* %49
%558 = load i32, i32* %11
%559 = add nsw i32 %558, 1
store i32 %559, i32* %12
br label %560
560: ; preds = %587, %549
%561 = load i32, i32* %12
%562 = load i32, i32* %9
%563 = icmp slt i32 %561, %562
br i1 %563, label %564, label %590
564: ; preds = %560
%565 = load double*, double** %8
%566 = load i32, i32* %12
%567 = sext i32 %566 to i64
%568 = getelementptr inbounds double, double* %565, i64 %567
%569 = load double, double* %568
%570 = call double @llvm.fabs.f64(double %569)
store double %570, double* %52
%571 = load double, double* %52
store double %571, double* %51
%572 = load double, double* %49
%573 = load double, double* %51
%574 = fcmp olt double %572, %573
br i1 %574, label %575, label %577
575: ; preds = %564
%576 = load i32, i32* %12
store i32 %576, i32* %48
br label %579
577: ; preds = %564
%578 = load i32, i32* %48
store i32 %578, i32* %48
br label %579
579: ; preds = %577, %575
%580 = load double, double* %49
%581 = load double, double* %51
%582 = fcmp olt double %580, %581
br i1 %582, label %583, label %585
583: ; preds = %579
%584 = load double, double* %51
store double %584, double* %49
br label %587
585: ; preds = %579
%586 = load double, double* %49
store double %586, double* %49
br label %587
587: ; preds = %585, %583
%588 = load i32, i32* %12
%589 = add nsw i32 %588, 1
store i32 %589, i32* %12
br label %560
590: ; preds = %560
%591 = load i32, i32* %48
%592 = load i32, i32* %11
%593 = icmp ne i32 %591, %592
br i1 %593, label %594, label %651
594: ; preds = %590
%595 = load double*, double** %8
%596 = load i32, i32* %11
%597 = sext i32 %596 to i64
%598 = getelementptr inbounds double, double* %595, i64 %597
%599 = load double, double* %598
store double %599, double* %54
%600 = load double*, double** %8
%601 = load i32, i32* %48
%602 = sext i32 %601 to i64
%603 = getelementptr inbounds double, double* %600, i64 %602
%604 = load double, double* %603
%605 = load double*, double** %8
%606 = load i32, i32* %11
%607 = sext i32 %606 to i64
%608 = getelementptr inbounds double, double* %605, i64 %607
store double %604, double* %608
%609 = load double, double* %54
%610 = load double*, double** %8
%611 = load i32, i32* %48
%612 = sext i32 %611 to i64
%613 = getelementptr inbounds double, double* %610, i64 %612
store double %609, double* %613
store i32 0, i32* %12
%614 = load i32, i32* %11
%615 = load i32, i32* %9
%616 = mul nsw i32 %614, %615
store i32 %616, i32* %13
%617 = load i32, i32* %48
%618 = load i32, i32* %9
%619 = mul nsw i32 %617, %618
store i32 %619, i32* %53
br label %620
620: ; preds = %624, %594
%621 = load i32, i32* %12
%622 = load i32, i32* %9
%623 = icmp slt i32 %621, %622
br i1 %623, label %624, label %650
624: ; preds = %620
%625 = load double*, double** %7
%626 = load i32, i32* %13
%627 = sext i32 %626 to i64
%628 = getelementptr inbounds double, double* %625, i64 %627
%629 = load double, double* %628
store double %629, double* %54
%630 = load double*, double** %7
%631 = load i32, i32* %53
%632 = sext i32 %631 to i64
%633 = getelementptr inbounds double, double* %630, i64 %632
%634 = load double, double* %633
%635 = load double*, double** %7
%636 = load i32, i32* %13
%637 = sext i32 %636 to i64
%638 = getelementptr inbounds double, double* %635, i64 %637
store double %634, double* %638
%639 = load double, double* %54
%640 = load double*, double** %7
%641 = load i32, i32* %53
%642 = sext i32 %641 to i64
%643 = getelementptr inbounds double, double* %640, i64 %642
store double %639, double* %643
%644 = load i32, i32* %12
%645 = add nsw i32 %644, 1
store i32 %645, i32* %12
%646 = load i32, i32* %13
%647 = add nsw i32 %646, 1
store i32 %647, i32* %13
%648 = load i32, i32* %53
%649 = add nsw i32 %648, 1
store i32 %649, i32* %53
br label %620
650: ; preds = %620
br label %651
651: ; preds = %650, %590
%652 = load i32, i32* %11
%653 = add nsw i32 %652, 1
store i32 %653, i32* %11
br label %545
654: ; preds = %545
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 = fmul double %201, %201
%203 = tail call double @llvm.fmuladd.f64(double %193, double %193, double %202)
%204 = tail call double @sqrt(double %203)
%205 = fneg double %193
%206 = fdiv double %205, %204
%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 [ %185, %182 ], [ 1, %390 ]
%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
}