#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(float);
double sqrt(double);
int cvJacobiEigens_32f(float *A, float *V, float *E, int n, float eps) {
  int i, j, k, ind;
  float *AA = A, *VV = V;
  double Amax, anorm = 0, ax;
  if (eps < 1.0e-7f)
    eps = 1.0e-7f;
  for (i = 0; i < n; i++, VV += n, AA += n) {
    for (j = 0; j < i; j++) {
      double Am = AA[j];
      anorm += Am * Am;
    }
    for (j = 0; j < n; j++)
      VV[j] = 0.f;
    VV[i] = 1.f;
  }
  anorm = sqrt(anorm + anorm);
  ax = anorm * eps / n;
  Amax = anorm;
  while (Amax > ax) {
    Amax /= n;
    do {
      int p, q;
      float *V1 = V, *A1 = A;
      ind = 0;
      for (p = 0; p < n - 1; p++, A1 += n, V1 += n) {
        float *A2 = A + n * (p + 1), *V2 = V + n * (p + 1);
        for (q = p + 1; q < n; q++, A2 += n, V2 += n) {
          double x, y, c, s, c2, s2, a;
          float *A3, Apq = A1[q], App, Aqq, Aip, Aiq, Vpi, Vqi;
          if (fabs(Apq) < Amax)
            continue;
          ind = 1;
          App = A1[p];
          Aqq = A2[q];
          y = 5.0e-1 * (App - Aqq);
          x = -Apq / sqrt(Apq * Apq + y * y);
          if (y < 0.0)
            x = -x;
          s = x / sqrt(2.0 * (1.0 + sqrt(1.0 - x * x)));
          s2 = s * s;
          c = sqrt(1.0 - s2);
          c2 = c * c;
          a = 2.0 * Apq * c * s;
          A3 = A;
          for (i = 0; i < p; i++, A3 += n) {
            Aip = A3[p];
            Aiq = A3[q];
            Vpi = V1[i];
            Vqi = V2[i];
            A3[p] = (float)(Aip * c - Aiq * s);
            A3[q] = (float)(Aiq * c + Aip * s);
            V1[i] = (float)(Vpi * c - Vqi * s);
            V2[i] = (float)(Vqi * c + Vpi * s);
          }
          for (; i < q; i++, A3 += n) {
            Aip = A1[i];
            Aiq = A3[q];
            Vpi = V1[i];
            Vqi = V2[i];
            A1[i] = (float)(Aip * c - Aiq * s);
            A3[q] = (float)(Aiq * c + Aip * s);
            V1[i] = (float)(Vpi * c - Vqi * s);
            V2[i] = (float)(Vqi * c + Vpi * s);
          }
          for (; i < n; i++) {
            Aip = A1[i];
            Aiq = A2[i];
            Vpi = V1[i];
            Vqi = V2[i];
            A1[i] = (float)(Aip * c - Aiq * s);
            A2[i] = (float)(Aiq * c + Aip * s);
            V1[i] = (float)(Vpi * c - Vqi * s);
            V2[i] = (float)(Vqi * c + Vpi * s);
          }
          A1[p] = (float)(App * c2 + Aqq * s2 - a);
          A2[q] = (float)(App * s2 + Aqq * c2 + a);
          A1[q] = A2[p] = 0.0f;
        }
      }
    } while (ind);
    Amax /= n;
  }
  for (i = 0, k = 0; i < n; i++, k += n + 1)
    E[i] = A[k];
  for (i = 0; i < n; i++) {
    int m = i;
    float Em = (float)fabs(E[i]);
    for (j = i + 1; j < n; j++) {
      float Ej = (float)fabs(E[j]);
      m = (Em < Ej) ? j : m;
      Em = (Em < Ej) ? Ej : Em;
    }
    if (m != i) {
      int l;
      float b = E[i];
      E[i] = E[m];
      E[m] = b;
      for (j = 0, k = i * n, l = m * n; j < n; j++, k++, l++) {
        b = V[k];
        V[k] = V[l];
        V[l] = b;
      }
    }
  }
  return 0;
}


x86 assembly (clang, -O0):
<cvJacobiEigens_32f>:
push   %rbp
mov    %rsp,%rbp
sub    $0x110,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x40(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
movss  0xea1(%rip),%xmm0
ucomiss -0x20(%rbp),%xmm0
jbe    1176 <cvJacobiEigens_32f+0x56>
movss  0xe8f(%rip),%xmm0
movss  %xmm0,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    125a <cvJacobiEigens_32f+0x13a>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    11dc <cvJacobiEigens_32f+0xbc>
mov    -0x38(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1190 <cvJacobiEigens_32f+0x70>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    120d <cvJacobiEigens_32f+0xed>
mov    -0x40(%rbp),%rax
movslq -0x28(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11e3 <cvJacobiEigens_32f+0xc3>
mov    -0x40(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  0xde7(%rip),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x1c(%rbp),%ecx
mov    -0x40(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x1c(%rbp),%ecx
mov    -0x38(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
jmp    117d <cvJacobiEigens_32f+0x5d>
movsd  -0x50(%rbp),%xmm0
addsd  -0x50(%rbp),%xmm0
call   1040 <sqrt@plt>
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
movss  -0x20(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
cvtsi2sdl -0x1c(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
ucomisd -0x58(%rbp),%xmm0
jbe    1c18 <cvJacobiEigens_32f+0xaf8>
cvtsi2sdl -0x1c(%rbp),%xmm1
movsd  -0x48(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x78(%rbp)
movl   $0x0,-0x30(%rbp)
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1bf1 <cvJacobiEigens_32f+0xad1>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    -0x64(%rbp),%edx
add    $0x1,%edx
imul   %edx,%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x80(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    -0x64(%rbp),%edx
add    $0x1,%edx
imul   %edx,%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x88(%rbp)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1bb4 <cvJacobiEigens_32f+0xa94>
mov    -0x78(%rbp),%rax
movslq -0x68(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xcc(%rbp)
ff
movss  -0xcc(%rbp),%xmm0
ff
call   1030 <fabs@plt>
movaps %xmm0,%xmm1
movsd  -0x48(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1377 <cvJacobiEigens_32f+0x257>
jmp    1b76 <cvJacobiEigens_32f+0xa56>
movl   $0x1,-0x30(%rbp)
mov    -0x78(%rbp),%rax
movslq -0x64(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xd0(%rbp)
ff
mov    -0x80(%rbp),%rax
movslq -0x68(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xd4(%rbp)
ff
movss  -0xd0(%rbp),%xmm0
ff
subss  -0xd4(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movsd  0xc44(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movss  -0xcc(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
movss  -0xcc(%rbp),%xmm0
ff
mulss  -0xcc(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0x98(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1040 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0x100(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
xorps  %xmm0,%xmm0
ucomisd -0x98(%rbp),%xmm0
ff
jbe    1471 <cvJacobiEigens_32f+0x351>
movsd  -0x90(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x108(%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  0xb64(%rip),%xmm1
addsd  %xmm1,%xmm0
call   1040 <sqrt@plt>
movsd  0xb53(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0xb3f(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1040 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0x108(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
mulsd  -0xa8(%rbp),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  0xb07(%rip),%xmm0
subsd  -0xb8(%rbp),%xmm0
ff
call   1040 <sqrt@plt>
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
mulsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
movss  -0xcc(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movsd  0xabe(%rip),%xmm0
mulsd  %xmm1,%xmm0
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,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x64(%rbp),%eax
jge    174d <cvJacobiEigens_32f+0x62d>
mov    -0xc8(%rbp),%rax
movslq -0x64(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xd8(%rbp)
ff
mov    -0xc8(%rbp),%rax
movslq -0x68(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xdc(%rbp)
ff
mov    -0x70(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xe0(%rbp)
ff
mov    -0x88(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xe4(%rbp)
ff
movss  -0xd8(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  -0xa0(%rbp),%xmm2
ff
movss  -0xdc(%rbp),%xmm1
ff
cvtss2sd %xmm1,%xmm1
mulsd  -0xa8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0xc8(%rbp),%rax
movslq -0x64(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xdc(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  -0xa0(%rbp),%xmm2
ff
movss  -0xd8(%rbp),%xmm1
ff
cvtss2sd %xmm1,%xmm1
mulsd  -0xa8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0xc8(%rbp),%rax
movslq -0x68(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xe0(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  -0xa0(%rbp),%xmm2
ff
movss  -0xe4(%rbp),%xmm1
ff
cvtss2sd %xmm1,%xmm1
mulsd  -0xa8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x70(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xe4(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  -0xa0(%rbp),%xmm2
ff
movss  -0xe0(%rbp),%xmm1
ff
cvtss2sd %xmm1,%xmm1
mulsd  -0xa8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x88(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x1c(%rbp),%ecx
mov    -0xc8(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0xc8(%rbp)
jmp    1580 <cvJacobiEigens_32f+0x460>
jmp    1752 <cvJacobiEigens_32f+0x632>
mov    -0x24(%rbp),%eax
cmp    -0x68(%rbp),%eax
jge    1919 <cvJacobiEigens_32f+0x7f9>
mov    -0x78(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xd8(%rbp)
ff
mov    -0xc8(%rbp),%rax
movslq -0x68(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xdc(%rbp)
ff
mov    -0x70(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xe0(%rbp)
ff
mov    -0x88(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xe4(%rbp)
ff
movss  -0xd8(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  -0xa0(%rbp),%xmm2
ff
movss  -0xdc(%rbp),%xmm1
ff
cvtss2sd %xmm1,%xmm1
mulsd  -0xa8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x78(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xdc(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  -0xa0(%rbp),%xmm2
ff
movss  -0xd8(%rbp),%xmm1
ff
cvtss2sd %xmm1,%xmm1
mulsd  -0xa8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0xc8(%rbp),%rax
movslq -0x68(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xe0(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  -0xa0(%rbp),%xmm2
ff
movss  -0xe4(%rbp),%xmm1
ff
cvtss2sd %xmm1,%xmm1
mulsd  -0xa8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x70(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xe4(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  -0xa0(%rbp),%xmm2
ff
movss  -0xe0(%rbp),%xmm1
ff
cvtss2sd %xmm1,%xmm1
mulsd  -0xa8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x88(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x1c(%rbp),%ecx
mov    -0xc8(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0xc8(%rbp)
jmp    1752 <cvJacobiEigens_32f+0x632>
jmp    191e <cvJacobiEigens_32f+0x7fe>
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1ac4 <cvJacobiEigens_32f+0x9a4>
mov    -0x78(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xd8(%rbp)
ff
mov    -0x80(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xdc(%rbp)
ff
mov    -0x70(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xe0(%rbp)
ff
mov    -0x88(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xe4(%rbp)
ff
movss  -0xd8(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  -0xa0(%rbp),%xmm2
ff
movss  -0xdc(%rbp),%xmm1
ff
cvtss2sd %xmm1,%xmm1
mulsd  -0xa8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x78(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xdc(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  -0xa0(%rbp),%xmm2
ff
movss  -0xd8(%rbp),%xmm1
ff
cvtss2sd %xmm1,%xmm1
mulsd  -0xa8(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x80(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xe0(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  -0xa0(%rbp),%xmm2
ff
movss  -0xe4(%rbp),%xmm1
ff
cvtss2sd %xmm1,%xmm1
mulsd  -0xa8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x70(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xe4(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  -0xa0(%rbp),%xmm2
ff
movss  -0xe0(%rbp),%xmm1
ff
cvtss2sd %xmm1,%xmm1
mulsd  -0xa8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x88(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    191e <cvJacobiEigens_32f+0x7fe>
movss  -0xd0(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  -0xb0(%rbp),%xmm2
ff
movss  -0xd4(%rbp),%xmm1
ff
cvtss2sd %xmm1,%xmm1
mulsd  -0xb8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
subsd  -0xc0(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x78(%rbp),%rax
movslq -0x64(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xd0(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  -0xb8(%rbp),%xmm2
ff
movss  -0xd4(%rbp),%xmm1
ff
cvtss2sd %xmm1,%xmm1
mulsd  -0xb0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
addsd  -0xc0(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x80(%rbp),%rax
movslq -0x68(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x80(%rbp),%rax
movslq -0x64(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x78(%rbp),%rax
movslq -0x68(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
mov    -0x1c(%rbp),%ecx
mov    -0x80(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x80(%rbp)
mov    -0x1c(%rbp),%ecx
mov    -0x88(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x88(%rbp)
jmp    1332 <cvJacobiEigens_32f+0x212>
jmp    1bb9 <cvJacobiEigens_32f+0xa99>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
mov    -0x1c(%rbp),%ecx
mov    -0x78(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x78(%rbp)
mov    -0x1c(%rbp),%ecx
mov    -0x70(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
jmp    12d9 <cvJacobiEigens_32f+0x1b9>
jmp    1bf6 <cvJacobiEigens_32f+0xad6>
cmpl   $0x0,-0x30(%rbp)
jne    12bb <cvJacobiEigens_32f+0x19b>
cvtsi2sdl -0x1c(%rbp),%xmm1
movsd  -0x48(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
jmp    1298 <cvJacobiEigens_32f+0x178>
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1c66 <cvJacobiEigens_32f+0xb46>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
jmp    1c26 <cvJacobiEigens_32f+0xb06>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1e7c <cvJacobiEigens_32f+0xd5c>
mov    -0x24(%rbp),%eax
mov    %eax,-0xe8(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1030 <fabs@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0xec(%rbp)
ff
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1d6e <cvJacobiEigens_32f+0xc4e>
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1030 <fabs@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0xf0(%rbp)
ff
movss  -0xec(%rbp),%xmm1
ff
movss  -0xf0(%rbp),%xmm0
ff
ucomiss %xmm1,%xmm0
jbe    1cfa <cvJacobiEigens_32f+0xbda>
mov    -0x28(%rbp),%eax
mov    %eax,-0x10c(%rbp)
jmp    1d06 <cvJacobiEigens_32f+0xbe6>
mov    -0xe8(%rbp),%eax
mov    %eax,-0x10c(%rbp)
mov    -0x10c(%rbp),%eax
mov    %eax,-0xe8(%rbp)
movss  -0xec(%rbp),%xmm1
ff
movss  -0xf0(%rbp),%xmm0
ff
ucomiss %xmm1,%xmm0
jbe    1d40 <cvJacobiEigens_32f+0xc20>
movss  -0xf0(%rbp),%xmm0
ff
movss  %xmm0,-0x110(%rbp)
ff
jmp    1d50 <cvJacobiEigens_32f+0xc30>
movss  -0xec(%rbp),%xmm0
ff
movss  %xmm0,-0x110(%rbp)
ff
movss  -0x110(%rbp),%xmm0
ff
movss  %xmm0,-0xec(%rbp)
ff
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1ca9 <cvJacobiEigens_32f+0xb89>
mov    -0xe8(%rbp),%eax
cmp    -0x24(%rbp),%eax
je     1e69 <cvJacobiEigens_32f+0xd49>
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xf8(%rbp)
ff
mov    -0x18(%rbp),%rax
movslq -0xe8(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xf8(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0xe8(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movl   $0x0,-0x28(%rbp)
mov    -0x24(%rbp),%eax
imul   -0x1c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0xe8(%rbp),%eax
imul   -0x1c(%rbp),%eax
mov    %eax,-0xf4(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1e64 <cvJacobiEigens_32f+0xd44>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xf8(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0xf4(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xf8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0xf4(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0xf4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xf4(%rbp)
jmp    1de8 <cvJacobiEigens_32f+0xcc8>
jmp    1e69 <cvJacobiEigens_32f+0xd49>
jmp    1e6e <cvJacobiEigens_32f+0xd4e>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1c6d <cvJacobiEigens_32f+0xb4d>
xor    %eax,%eax
add    $0x110,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<cvJacobiEigens_32f>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x118,%rsp
movss  %xmm0,0x70(%rsp)
mov    %rdx,%r12
mov    %rsi,0x48(%rsp)
mov    %rdi,0x28(%rsp)
movss  0x1ea4(%rip),%xmm0
movss  %xmm0,(%rsp)
mov    %ecx,%eax
mov    %rax,0x50(%rsp)
xorpd  %xmm2,%xmm2
mov    %rcx,0x18(%rsp)
test   %ecx,%ecx
jle    128f <cvJacobiEigens_32f+0x15f>
mov    0x50(%rsp),%rax
lea    0x0(,%rax,4),%r15
xorpd  %xmm2,%xmm2
xor    %ebx,%ebx
mov    0x28(%rsp),%rbp
mov    0x48(%rsp),%r14
jmp    11da <cvJacobiEigens_32f+0xaa>
nopl   0x0(%rax,%rax,1)
movsd  %xmm2,0x8(%rsp)
mov    %r14,%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1030 <memset@plt>
movsd  0x8(%rsp),%xmm2
movl   $0x3f800000,(%r14,%rbx,4)
3f
add    $0x1,%rbx
mov    0x50(%rsp),%rax
lea    (%r14,%rax,4),%r14
add    %r15,%rbp
cmp    %rax,%rbx
je     128f <cvJacobiEigens_32f+0x15f>
test   %rbx,%rbx
je     11a0 <cvJacobiEigens_32f+0x70>
lea    -0x1(%rbx),%rax
cmp    $0x3,%rax
jae    11f0 <cvJacobiEigens_32f+0xc0>
xor    %eax,%eax
jmp    1254 <cvJacobiEigens_32f+0x124>
nopl   (%rax)
mov    %rbx,%rcx
and    $0xfffffffffffffffc,%rcx
xor    %eax,%eax
nopl   0x0(%rax)
movss  0x0(%rbp,%rax,4),%xmm0
movss  0x4(%rbp,%rax,4),%xmm1
cvtss2sd %xmm0,%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm2,%xmm0
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movss  0x8(%rbp,%rax,4),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movss  0xc(%rbp,%rax,4),%xmm1
xorps  %xmm2,%xmm2
cvtss2sd %xmm1,%xmm2
mulsd  %xmm2,%xmm2
addsd  %xmm0,%xmm2
add    $0x4,%rax
cmp    %rax,%rcx
jne    1200 <cvJacobiEigens_32f+0xd0>
test   $0x3,%bl
je     11a0 <cvJacobiEigens_32f+0x70>
mov    %ebx,%ecx
and    $0x3,%ecx
lea    0x0(,%rax,4),%rax
add    %rbp,%rax
xor    %edx,%edx
nop
movss  (%rax,%rdx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm2
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    1270 <cvJacobiEigens_32f+0x140>
jmp    11a0 <cvJacobiEigens_32f+0x70>
movss  (%rsp),%xmm0
maxss  0x70(%rsp),%xmm0
movss  %xmm0,(%rsp)
addsd  %xmm2,%xmm2
ucomisd 0x1d6d(%rip),%xmm2
mov    %r12,0xc0(%rsp)
jb     12be <cvJacobiEigens_32f+0x18e>
xorps  %xmm0,%xmm0
sqrtsd %xmm2,%xmm0
jmp    12c7 <cvJacobiEigens_32f+0x197>
movapd %xmm2,%xmm0
call   1050 <sqrt@plt>
mov    0x18(%rsp),%rbx
mov    0x48(%rsp),%r8
movss  (%rsp),%xmm1
cvtss2sd %xmm1,%xmm1
xorps  %xmm2,%xmm2
cvtsi2sd %ebx,%xmm2
mulsd  %xmm0,%xmm1
divsd  %xmm2,%xmm1
movsd  %xmm1,0xd0(%rsp)
ucomisd %xmm1,%xmm0
jbe    1c7c <cvJacobiEigens_32f+0xb4c>
movabs $0x1fffffff8,%rax
lea    -0x1(%rbx),%edx
mov    %rdx,0xe0(%rsp)
movslq %ebx,%r9
lea    0x1(%r9),%rdx
mov    %rdx,0xd8(%rsp)
lea    0x0(,%r9,4),%rdx
add    $0x4,%rax
mov    %rax,0xe8(%rsp)
mov    %r9,0xb8(%rsp)
movsd  %xmm2,0xc8(%rsp)
mov    %rdx,0x20(%rsp)
jmp    1372 <cvJacobiEigens_32f+0x242>
nopl   0x0(%rax)
movsd  0x60(%rsp),%xmm0
movsd  0xc8(%rsp),%xmm2
divsd  %xmm2,%xmm0
ucomisd 0xd0(%rsp),%xmm0
jbe    1c7c <cvJacobiEigens_32f+0xb4c>
divsd  %xmm2,%xmm0
movsd  %xmm0,0x60(%rsp)
cmp    $0x2,%ebx
jl     1350 <cvJacobiEigens_32f+0x220>
xor    %r15d,%r15d
mov    $0x1,%esi
movl   $0x0,0x30(%rsp)
mov    0x28(%rsp),%r12
mov    %r8,%r13
nopl   0x0(%rax)
lea    0x1(%r15),%rcx
cmp    %r9,%rcx
mov    %rsi,0xf8(%rsp)
mov    %rcx,0xf0(%rsp)
jge    1c10 <cvJacobiEigens_32f+0xae0>
mov    %r15,%rax
imul   %r9,%rax
mov    0x28(%rsp),%rbp
lea    0x4(,%rax,4),%rdi
add    %rbp,%rdi
mov    %rdi,0x110(%rsp)
mov    0xd8(%rsp),%rdi
add    %rax,%rdi
mov    %rdi,0x108(%rsp)
lea    (%r8,%rax,4),%rax
add    $0x4,%rax
mov    %rax,0x100(%rsp)
mov    %rcx,%rax
imul   %r9,%rax
mov    %r8,%rcx
lea    (%r8,%rax,4),%r14
lea    0x0(,%rax,4),%rax
add    %rbp,%rax
mov    %rax,0x8(%rsp)
lea    0x0(,%rsi,4),%rbp
xor    %eax,%eax
mov    %rax,0x68(%rsp)
mov    %rsi,%rdi
jmp    14eb <cvJacobiEigens_32f+0x3bb>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
xorps  %xmm1,%xmm1
cvtss2sd %xmm14,%xmm1
addsd  %xmm1,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm0
mulsd  %xmm7,%xmm1
xorps  %xmm2,%xmm2
cvtss2sd %xmm15,%xmm2
movss  0xb0(%rsp),%xmm3
cvtss2sd %xmm3,%xmm3
movapd %xmm9,%xmm4
mulsd  %xmm3,%xmm4
movaps %xmm2,%xmm5
mulsd  %xmm0,%xmm5
addsd  %xmm4,%xmm5
subsd  %xmm1,%xmm5
xorps  %xmm4,%xmm4
cvtsd2ss %xmm5,%xmm4
movss  %xmm4,(%r12,%r15,4)
mulsd  %xmm3,%xmm0
mulsd  %xmm9,%xmm2
addsd  %xmm0,%xmm2
addsd  %xmm1,%xmm2
xorps  %xmm0,%xmm0
cvtsd2ss %xmm2,%xmm0
movss  %xmm0,(%rsi,%rdi,4)
movl   $0x0,(%rsi,%r15,4)
movl   $0x0,(%r12,%rdi,4)
movl   $0x1,0x30(%rsp)
add    $0x1,%rdi
add    %rdx,%rsi
mov    %rsi,0x8(%rsp)
add    %rdx,%r14
addq   $0x1,0x68(%rsp)
add    $0x4,%rbp
cmp    0x50(%rsp),%rdi
je     1c10 <cvJacobiEigens_32f+0xae0>
mov    %rdi,(%rsp)
movss  (%r12,%rdi,4),%xmm0
movapd %xmm0,0x70(%rsp)
call   1040 <fabs@plt>
mov    (%rsp),%rdi
mov    0x20(%rsp),%rdx
movsd  0x60(%rsp),%xmm1
ucomisd %xmm0,%xmm1
mov    0x8(%rsp),%rsi
ja     14c7 <cvJacobiEigens_32f+0x397>
movss  (%r12,%r15,4),%xmm2
movss  (%rsi,%rdi,4),%xmm4
movaps %xmm2,%xmm0
subss  %xmm4,%xmm0
xorps  %xmm5,%xmm5
cvtss2sd %xmm0,%xmm5
mulsd  0x1acd(%rip),%xmm5
movaps 0x70(%rsp),%xmm3
movaps %xmm3,%xmm0
mulss  %xmm3,%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm0,%xmm1
movapd %xmm5,%xmm0
mulsd  %xmm5,%xmm0
addsd  %xmm1,%xmm0
ucomisd 0x1ab6(%rip),%xmm0
movss  %xmm2,0x58(%rsp)
movss  %xmm4,0xb0(%rsp)
jb     1580 <cvJacobiEigens_32f+0x450>
sqrtsd %xmm0,%xmm0
jmp    1596 <cvJacobiEigens_32f+0x466>
nopl   0x0(%rax)
movapd %xmm5,0x30(%rsp)
call   1050 <sqrt@plt>
movapd 0x30(%rsp),%xmm5
movaps 0x70(%rsp),%xmm3
movaps %xmm3,%xmm1
xorps  0x1a80(%rip),%xmm1
xorps  %xmm4,%xmm4
cvtss2sd %xmm1,%xmm4
divsd  %xmm0,%xmm4
xorps  %xmm2,%xmm2
cmpltsd %xmm2,%xmm5
movapd %xmm5,%xmm0
andnpd %xmm4,%xmm0
xorpd  0x1a6d(%rip),%xmm4
andpd  %xmm5,%xmm4
orpd   %xmm0,%xmm4
movapd %xmm4,%xmm1
mulsd  %xmm4,%xmm1
movsd  0x1a35(%rip),%xmm0
subsd  %xmm1,%xmm0
ucomisd %xmm2,%xmm0
movapd %xmm4,0x30(%rsp)
jb     1600 <cvJacobiEigens_32f+0x4d0>
sqrtsd %xmm0,%xmm0
jmp    1605 <cvJacobiEigens_32f+0x4d5>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
call   1050 <sqrt@plt>
addsd  0x1a03(%rip),%xmm0
addsd  %xmm0,%xmm0
ucomisd 0x19ff(%rip),%xmm0
jb     1630 <cvJacobiEigens_32f+0x500>
sqrtsd %xmm0,%xmm0
jmp    1635 <cvJacobiEigens_32f+0x505>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
call   1050 <sqrt@plt>
movapd 0x30(%rsp),%xmm7
divsd  %xmm0,%xmm7
movapd %xmm7,%xmm9
mulsd  %xmm7,%xmm9
movsd  0x19bf(%rip),%xmm0
subsd  %xmm9,%xmm0
ucomisd 0x19ba(%rip),%xmm0
jb     1670 <cvJacobiEigens_32f+0x540>
sqrtsd %xmm0,%xmm0
jmp    1695 <cvJacobiEigens_32f+0x565>
cs nopw 0x0(%rax,%rax,1)
movapd %xmm7,0x30(%rsp)
movapd %xmm9,0x80(%rsp)
call   1050 <sqrt@plt>
movapd 0x80(%rsp),%xmm9
movapd 0x30(%rsp),%xmm7
mov    0x20(%rsp),%rdx
mov    0x8(%rsp),%rsi
mov    (%rsp),%rdi
movaps 0x70(%rsp),%xmm14
movss  0x58(%rsp),%xmm15
test   %r15,%r15
je     1781 <cvJacobiEigens_32f+0x651>
movapd %xmm7,%xmm1
xorpd  0x196b(%rip),%xmm1
mov    0x28(%rsp),%rax
xor    %ecx,%ecx
nopl   0x0(%rax)
movss  (%rax,%r15,4),%xmm2
movss  (%rax,%rbp,1),%xmm3
movss  0x0(%r13,%rcx,4),%xmm4
cvtss2sd %xmm2,%xmm2
cvtss2sd %xmm3,%xmm3
movapd %xmm1,%xmm5
mulsd  %xmm3,%xmm5
movapd %xmm7,%xmm6
mulsd  %xmm2,%xmm6
mulsd  %xmm0,%xmm2
addsd  %xmm5,%xmm2
cvtsd2ss %xmm2,%xmm2
movss  (%r14,%rcx,4),%xmm5
movss  %xmm2,(%rax,%r15,4)
mulsd  %xmm0,%xmm3
addsd  %xmm6,%xmm3
xorps  %xmm2,%xmm2
cvtsd2ss %xmm3,%xmm2
movss  %xmm2,(%rax,%rbp,1)
xorps  %xmm2,%xmm2
cvtss2sd %xmm4,%xmm2
xorps  %xmm3,%xmm3
cvtss2sd %xmm5,%xmm3
movapd %xmm1,%xmm4
mulsd  %xmm3,%xmm4
movapd %xmm7,%xmm5
mulsd  %xmm2,%xmm5
mulsd  %xmm0,%xmm2
addsd  %xmm4,%xmm2
cvtsd2ss %xmm2,%xmm2
movss  %xmm2,0x0(%r13,%rcx,4)
mulsd  %xmm0,%xmm3
addsd  %xmm5,%xmm3
xorps  %xmm2,%xmm2
cvtsd2ss %xmm3,%xmm2
movss  %xmm2,(%r14,%rcx,4)
add    $0x1,%rcx
add    %rdx,%rax
cmp    %rcx,%r15
jne    16d0 <cvJacobiEigens_32f+0x5a0>
mov    %r15d,%r8d
jmp    1789 <cvJacobiEigens_32f+0x659>
xor    %r8d,%r8d
mov    0x28(%rsp),%rax
mov    %r8d,%ecx
cmp    %rcx,%rdi
jbe    185d <cvJacobiEigens_32f+0x72d>
movapd %xmm7,%xmm1
xorpd  0x188f(%rip),%xmm1
lea    (%rax,%rdi,4),%rax
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%r12,%rcx,4),%xmm2
movss  (%rax),%xmm3
movss  0x0(%r13,%rcx,4),%xmm4
cvtss2sd %xmm2,%xmm2
cvtss2sd %xmm3,%xmm3
movapd %xmm1,%xmm5
mulsd  %xmm3,%xmm5
movapd %xmm7,%xmm6
mulsd  %xmm2,%xmm6
mulsd  %xmm0,%xmm2
addsd  %xmm5,%xmm2
cvtsd2ss %xmm2,%xmm2
movss  (%r14,%rcx,4),%xmm5
movss  %xmm2,(%r12,%rcx,4)
mulsd  %xmm0,%xmm3
addsd  %xmm6,%xmm3
xorps  %xmm2,%xmm2
cvtsd2ss %xmm3,%xmm2
movss  %xmm2,(%rax)
xorps  %xmm2,%xmm2
cvtss2sd %xmm4,%xmm2
xorps  %xmm3,%xmm3
cvtss2sd %xmm5,%xmm3
movapd %xmm1,%xmm4
mulsd  %xmm3,%xmm4
movapd %xmm7,%xmm5
mulsd  %xmm2,%xmm5
mulsd  %xmm0,%xmm2
addsd  %xmm4,%xmm2
cvtsd2ss %xmm2,%xmm2
movss  %xmm2,0x0(%r13,%rcx,4)
mulsd  %xmm0,%xmm3
addsd  %xmm5,%xmm3
xorps  %xmm2,%xmm2
cvtsd2ss %xmm3,%xmm2
movss  %xmm2,(%r14,%rcx,4)
add    $0x1,%rcx
add    %rdx,%rax
cmp    %rcx,%rdi
jne    17b0 <cvJacobiEigens_32f+0x680>
mov    %edi,%r8d
cmp    %ebx,%r8d
jge    1440 <cvJacobiEigens_32f+0x310>
movapd %xmm7,%xmm8
xorpd  0x17bc(%rip),%xmm8
mov    %r8d,%eax
not    %r8d
add    %ebx,%r8d
cmp    $0x3,%r8d
jb     1b60 <cvJacobiEigens_32f+0xa30>
mov    0x68(%rsp),%rcx
imul   0xb8(%rsp),%rcx
add    0x108(%rsp),%rcx
mov    0x28(%rsp),%rdx
lea    (%rdx,%rcx,4),%rdi
mov    0x48(%rsp),%rdx
lea    (%rdx,%rcx,4),%rcx
mov    %rcx,0x30(%rsp)
lea    (%r12,%rax,4),%r11
lea    (%r8,%rax,1),%rbx
mov    0x110(%rsp),%rcx
lea    (%rcx,%rbx,4),%r10
lea    (%rsi,%rax,4),%rsi
lea    (%rdi,%rbx,4),%rdx
lea    0x0(%r13,%rax,4),%rdi
mov    0x100(%rsp),%rcx
lea    (%rcx,%rbx,4),%rcx
mov    %rcx,0xa8(%rsp)
lea    (%r14,%rax,4),%rcx
mov    0x30(%rsp),%r9
lea    (%r9,%rbx,4),%r9
cmp    %rdx,%r11
setb   0x30(%rsp)
cmp    %r10,%rsi
setb   0x80(%rsp)
mov    0xa8(%rsp),%rbx
cmp    %rbx,%r11
setb   0xa0(%rsp)
cmp    %r10,%rdi
setb   0x98(%rsp)
cmp    %r9,%r11
setb   0x17(%rsp)
cmp    %r10,%rcx
setb   0x16(%rsp)
cmp    %rbx,%rsi
setb   %r10b
cmp    %rdx,%rdi
setb   0x14(%rsp)
cmp    %r9,%rsi
setb   0x13(%rsp)
cmp    %rdx,%rcx
setb   0x15(%rsp)
cmp    %r9,%rdi
setb   0x12(%rsp)
cmp    %rbx,%rcx
setb   %dl
mov    0x80(%rsp),%bl
test   %bl,0x30(%rsp)
jne    1b44 <cvJacobiEigens_32f+0xa14>
mov    0x98(%rsp),%bl
and    %bl,0xa0(%rsp)
mov    0x18(%rsp),%rbx
jne    1b49 <cvJacobiEigens_32f+0xa19>
mov    %dl,0x30(%rsp)
mov    0x15(%rsp),%r9b
mov    0x16(%rsp),%dl
and    %dl,0x17(%rsp)
jne    1b49 <cvJacobiEigens_32f+0xa19>
and    0x14(%rsp),%r10b
jne    1b49 <cvJacobiEigens_32f+0xa19>
and    %r9b,0x13(%rsp)
jne    1b49 <cvJacobiEigens_32f+0xa19>
mov    0x30(%rsp),%dl
and    %dl,0x12(%rsp)
jne    1b49 <cvJacobiEigens_32f+0xa19>
movapd %xmm9,0x80(%rsp)
add    $0x1,%r8
mov    %r8,%r9
and    0xe8(%rsp),%r9
add    %r9,%rax
movapd %xmm8,%xmm9
unpcklpd %xmm8,%xmm9
movapd %xmm0,%xmm11
unpcklpd %xmm0,%xmm11
movapd %xmm7,0x30(%rsp)
movapd %xmm7,%xmm10
unpcklpd %xmm7,%xmm10
xor    %ebx,%ebx
mov    0x20(%rsp),%rdx
cvtps2pd 0x8(%r11,%rbx,4),%xmm1
cvtps2pd (%r11,%rbx,4),%xmm13
cvtps2pd (%rsi,%rbx,4),%xmm7
cvtps2pd 0x8(%rsi,%rbx,4),%xmm4
movapd %xmm9,%xmm2
mulpd  %xmm4,%xmm2
movapd %xmm9,%xmm5
mulpd  %xmm7,%xmm5
movapd %xmm13,%xmm6
mulpd  %xmm11,%xmm6
addpd  %xmm5,%xmm6
movapd %xmm10,%xmm12
mulpd  %xmm1,%xmm12
mulpd  %xmm11,%xmm1
addpd  %xmm2,%xmm1
cvtpd2ps %xmm1,%xmm1
cvtpd2ps %xmm6,%xmm3
unpcklpd %xmm1,%xmm3
cvtps2pd 0x8(%rdi,%rbx,4),%xmm2
cvtps2pd (%rdi,%rbx,4),%xmm1
cvtps2pd (%rcx,%rbx,4),%xmm5
cvtps2pd 0x8(%rcx,%rbx,4),%xmm6
movupd %xmm3,(%r11,%rbx,4)
mulpd  %xmm10,%xmm13
mulpd  %xmm11,%xmm7
addpd  %xmm13,%xmm7
mulpd  %xmm11,%xmm4
addpd  %xmm12,%xmm4
cvtpd2ps %xmm4,%xmm3
cvtpd2ps %xmm7,%xmm4
unpcklpd %xmm3,%xmm4
movupd %xmm4,(%rsi,%rbx,4)
movapd %xmm9,%xmm3
mulpd  %xmm6,%xmm3
movapd %xmm9,%xmm4
mulpd  %xmm5,%xmm4
movapd %xmm10,%xmm7
mulpd  %xmm1,%xmm7
mulpd  %xmm11,%xmm1
addpd  %xmm4,%xmm1
movapd %xmm10,%xmm4
mulpd  %xmm2,%xmm4
mulpd  %xmm11,%xmm2
addpd  %xmm3,%xmm2
cvtpd2ps %xmm2,%xmm2
cvtpd2ps %xmm1,%xmm1
unpcklpd %xmm2,%xmm1
movupd %xmm1,(%rdi,%rbx,4)
mulpd  %xmm11,%xmm5
addpd  %xmm7,%xmm5
mulpd  %xmm11,%xmm6
addpd  %xmm4,%xmm6
cvtpd2ps %xmm6,%xmm1
cvtpd2ps %xmm5,%xmm2
unpcklpd %xmm1,%xmm2
movupd %xmm2,(%rcx,%rbx,4)
add    $0x4,%rbx
cmp    %rbx,%r9
jne    1a10 <cvJacobiEigens_32f+0x8e0>
cmp    %r9,%r8
mov    0x18(%rsp),%rbx
mov    0x8(%rsp),%rsi
mov    (%rsp),%rdi
movapd 0x30(%rsp),%xmm7
movapd 0x80(%rsp),%xmm9
jne    1b60 <cvJacobiEigens_32f+0xa30>
jmp    1440 <cvJacobiEigens_32f+0x310>
mov    0x18(%rsp),%rbx
mov    0x20(%rsp),%rdx
mov    0x8(%rsp),%rsi
mov    (%rsp),%rdi
nopw   0x0(%rax,%rax,1)
movss  (%r12,%rax,4),%xmm1
movss  (%rsi,%rax,4),%xmm2
movss  0x0(%r13,%rax,4),%xmm3
movss  (%r14,%rax,4),%xmm4
cvtss2sd %xmm1,%xmm1
cvtss2sd %xmm2,%xmm2
movapd %xmm8,%xmm5
mulsd  %xmm2,%xmm5
movapd %xmm7,%xmm6
mulsd  %xmm1,%xmm6
mulsd  %xmm0,%xmm1
addsd  %xmm5,%xmm1
cvtsd2ss %xmm1,%xmm1
movss  %xmm1,(%r12,%rax,4)
mulsd  %xmm0,%xmm2
addsd  %xmm6,%xmm2
xorps  %xmm1,%xmm1
cvtsd2ss %xmm2,%xmm1
movss  %xmm1,(%rsi,%rax,4)
xorps  %xmm1,%xmm1
cvtss2sd %xmm3,%xmm1
xorps  %xmm2,%xmm2
cvtss2sd %xmm4,%xmm2
movapd %xmm8,%xmm3
mulsd  %xmm2,%xmm3
movapd %xmm7,%xmm4
mulsd  %xmm1,%xmm4
mulsd  %xmm0,%xmm1
addsd  %xmm3,%xmm1
cvtsd2ss %xmm1,%xmm1
mulsd  %xmm0,%xmm2
addsd  %xmm4,%xmm2
cvtsd2ss %xmm2,%xmm2
movss  %xmm1,0x0(%r13,%rax,4)
movss  %xmm2,(%r14,%rax,4)
add    $0x1,%rax
cmp    %ebx,%eax
jl     1b60 <cvJacobiEigens_32f+0xa30>
jmp    1440 <cvJacobiEigens_32f+0x310>
nopl   0x0(%rax)
mov    0xb8(%rsp),%r9
lea    (%r12,%r9,4),%r12
lea    0x0(%r13,%r9,4),%r13
mov    0xf8(%rsp),%rsi
add    $0x1,%rsi
mov    0xf0(%rsp),%rax
mov    %rax,%r15
cmp    0xe0(%rsp),%rax
mov    0x48(%rsp),%r8
jne    13a0 <cvJacobiEigens_32f+0x270>
cmp    $0x2,%ebx
jl     1350 <cvJacobiEigens_32f+0x220>
xor    %r15d,%r15d
mov    $0x1,%esi
mov    0x28(%rsp),%r12
mov    %r8,%r13
cmpl   $0x0,0x30(%rsp)
movl   $0x0,0x30(%rsp)
jne    13a0 <cvJacobiEigens_32f+0x270>
jmp    1350 <cvJacobiEigens_32f+0x220>
test   %ebx,%ebx
mov    0xc0(%rsp),%r13
mov    0x50(%rsp),%r14
jle    218d <cvJacobiEigens_32f+0x105d>
mov    0x18(%rsp),%rcx
lea    0x1(%rcx),%eax
movslq %eax,%r10
cmp    $0x8,%ecx
jae    1caf <cvJacobiEigens_32f+0xb7f>
xor    %ecx,%ecx
xor    %edx,%edx
mov    0x28(%rsp),%r15
jmp    1d9c <cvJacobiEigens_32f+0xc6c>
lea    -0x1(%r14),%rcx
imul   %r10,%rcx
mov    0x28(%rsp),%r15
lea    (%r15,%rcx,4),%rdx
cmp    %r15,%rdx
mov    %rdx,%rcx
cmova  %r15,%rcx
cmovb  %r15,%rdx
add    $0x4,%rdx
cmp    %r13,%rdx
jbe    1cf0 <cvJacobiEigens_32f+0xbc0>
lea    0x0(,%r14,4),%rdx
add    %r13,%rdx
cmp    %rdx,%rcx
jae    1cf0 <cvJacobiEigens_32f+0xbc0>
xor    %ecx,%ecx
xor    %edx,%edx
jmp    1d9c <cvJacobiEigens_32f+0xc6c>
mov    %r14d,%edx
and    $0xfffffff8,%edx
mov    %rdx,%rcx
imul   %r10,%rcx
lea    0x0(,%r10,4),%r11
lea    0x0(,%r14,4),%r8
and    $0xffffffffffffffe0,%r8
mov    %r10,%r9
shl    $0x5,%r9
xor    %ebx,%ebx
mov    %r15,%rdi
nopl   (%rax)
lea    (%rdi,%r11,1),%rbp
add    %r11,%rbp
lea    (%r11,%rbp,1),%rax
movss  (%rdi,%r10,8),%xmm0
movss  0x0(%rbp,%r10,4),%xmm1
unpcklps %xmm1,%xmm0
movss  (%rdi,%r10,4),%xmm1
movss  (%rdi),%xmm2
unpcklps %xmm1,%xmm2
unpcklpd %xmm0,%xmm2
add    %r11,%rax
lea    (%rax,%r11,1),%rsi
movss  0x0(%rbp,%r10,8),%xmm0
movss  (%rax,%r10,4),%xmm1
unpcklps %xmm1,%xmm0
movss  (%rsi,%r10,4),%xmm1
add    %r11,%rsi
movss  (%rsi,%r10,4),%xmm3
unpcklps %xmm3,%xmm1
unpcklpd %xmm1,%xmm0
movupd %xmm2,0x0(%r13,%rbx,1)
movupd %xmm0,0x10(%r13,%rbx,1)
add    $0x20,%rbx
add    %r9,%rdi
cmp    %rbx,%r8
jne    1d20 <cvJacobiEigens_32f+0xbf0>
cmp    %r14,%rdx
je     1e30 <cvJacobiEigens_32f+0xd00>
mov    %rdx,%rsi
not    %rsi
add    %r14,%rsi
mov    %r14,%rdi
and    $0x3,%rdi
je     1dca <cvJacobiEigens_32f+0xc9a>
xchg   %ax,%ax
movss  (%r15,%rcx,4),%xmm0
movss  %xmm0,0x0(%r13,%rdx,4)
add    $0x1,%rdx
add    %r10,%rcx
add    $0xffffffffffffffff,%rdi
jne    1db0 <cvJacobiEigens_32f+0xc80>
cmp    $0x3,%rsi
jb     1e30 <cvJacobiEigens_32f+0xd00>
lea    0x0(,%rcx,4),%rsi
mov    %r10,%rdi
shl    $0x4,%rdi
lea    (%r10,%r10,2),%rax
lea    (%rsi,%rax,4),%rbp
lea    (%rsi,%r10,8),%rbx
add    %r10,%rcx
xchg   %ax,%ax
movss  (%r15,%rsi,1),%xmm0
movss  %xmm0,0x0(%r13,%rdx,4)
movss  (%r15,%rcx,4),%xmm0
movss  %xmm0,0x4(%r13,%rdx,4)
movss  (%r15,%rbx,1),%xmm0
movss  %xmm0,0x8(%r13,%rdx,4)
movss  (%r15,%rbp,1),%xmm0
movss  %xmm0,0xc(%r13,%rdx,4)
add    $0x4,%rdx
add    %rdi,%r15
cmp    %rdx,%r14
jne    1df0 <cvJacobiEigens_32f+0xcc0>
cmpl   $0x0,0x18(%rsp)
jle    218d <cvJacobiEigens_32f+0x105d>
mov    0x18(%rsp),%rax
lea    -0x1(%rax),%edx
mov    0x48(%rsp),%rcx
lea    (%rcx,%rdx,4),%rsi
add    $0x4,%rsi
mov    %rsi,0x60(%rsp)
mov    %rdx,0x30(%rsp)
add    $0x1,%rdx
mov    %rdx,0x28(%rsp)
and    $0xfffffffffffffff8,%rdx
mov    %rdx,0x58(%rsp)
add    $0xfffffffffffffff8,%rdx
mov    %rdx,0x80(%rsp)
mov    %rdx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %rsi,%rdx
mov    %rsi,0xa8(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,0xa0(%rsp)
neg    %eax
mov    %eax,0x68(%rsp)
lea    0x30(%rcx),%rax
mov    %rax,0x98(%rsp)
lea    0x4(%rcx),%rax
mov    %rax,0xb0(%rsp)
mov    $0x1,%r15d
xor    %ebp,%ebp
xor    %ebx,%ebx
jmp    1eeb <cvJacobiEigens_32f+0xdbb>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r15
add    0x18(%rsp),%ebx
mov    0x50(%rsp),%r14
mov    0x20(%rsp),%rbp
cmp    %r14,%rbp
je     218d <cvJacobiEigens_32f+0x105d>
mov    %ebx,0x70(%rsp)
mov    %r13,%r12
movss  0x0(%r13,%rbp,4),%xmm0
call   1040 <fabs@plt>
lea    0x1(%rbp),%rax
mov    %rax,0x20(%rsp)
cmp    %r14,%rax
mov    %r15,(%rsp)
jae    1f60 <cvJacobiEigens_32f+0xe30>
cvtsd2ss %xmm0,%xmm0
mov    %ebp,%r14d
mov    0x50(%rsp),%rbx
nopl   0x0(%rax)
movss  %xmm0,0x8(%rsp)
movss  (%r12,%r15,4),%xmm0
call   1040 <fabs@plt>
cvtsd2ss %xmm0,%xmm0
movss  0x8(%rsp),%xmm1
ucomiss %xmm1,%xmm0
cmova  %r15d,%r14d
maxss  %xmm1,%xmm0
add    $0x1,%r15
cmp    %r15,%rbx
jne    1f20 <cvJacobiEigens_32f+0xdf0>
jmp    1f63 <cvJacobiEigens_32f+0xe33>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %ebp,%r14d
mov    %r14d,%eax
cmp    %rax,%rbp
mov    %r12,%r13
mov    (%rsp),%r15
mov    0x70(%rsp),%ebx
je     1ed0 <cvJacobiEigens_32f+0xda0>
movslq %ebx,%r8
movslq %r14d,%rcx
imul   0x18(%rsp),%r14d
xor    %edx,%edx
movss  0x0(%r13,%rbp,4),%xmm0
movss  0x0(%r13,%rcx,4),%xmm1
movss  %xmm1,0x0(%r13,%rbp,4)
movss  %xmm0,0x0(%r13,%rcx,4)
movslq %r14d,%rcx
cmpl   $0x7,0x30(%rsp)
jae    1fc0 <cvJacobiEigens_32f+0xe90>
mov    0x48(%rsp),%rax
jmp    1ffa <cvJacobiEigens_32f+0xeca>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x48(%rsp),%rax
lea    (%rax,%r8,4),%rsi
mov    0x60(%rsp),%rbp
lea    0x0(,%rcx,4),%rdi
add    %rbp,%rdi
cmp    %rdi,%rsi
jae    2099 <cvJacobiEigens_32f+0xf69>
lea    0x0(,%r8,4),%rsi
add    %rbp,%rsi
lea    (%rax,%rcx,4),%rdi
cmp    %rsi,%rdi
jae    2099 <cvJacobiEigens_32f+0xf69>
mov    0x18(%rsp),%rsi
sub    %edx,%esi
test   $0x1,%sil
jne    2010 <cvJacobiEigens_32f+0xee0>
mov    %edx,%esi
jmp    2031 <cvJacobiEigens_32f+0xf01>
nopl   0x0(%rax,%rax,1)
movss  (%rax,%r8,4),%xmm0
movss  (%rax,%rcx,4),%xmm1
movss  %xmm1,(%rax,%r8,4)
movss  %xmm0,(%rax,%rcx,4)
lea    0x1(%rdx),%esi
add    $0x1,%r8
add    $0x1,%rcx
not    %edx
cmp    0x68(%rsp),%edx
je     1ed0 <cvJacobiEigens_32f+0xda0>
mov    0xb0(%rsp),%rdx
lea    (%rdx,%r8,4),%rax
lea    (%rdx,%rcx,4),%rcx
mov    0x18(%rsp),%rdx
sub    %esi,%edx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
movss  -0x4(%rax,%rsi,4),%xmm0
movss  -0x4(%rcx,%rsi,4),%xmm1
movss  %xmm1,-0x4(%rax,%rsi,4)
movss  %xmm0,-0x4(%rcx,%rsi,4)
movss  (%rax,%rsi,4),%xmm0
movss  (%rcx,%rsi,4),%xmm1
movss  %xmm1,(%rax,%rsi,4)
movss  %xmm0,(%rcx,%rsi,4)
add    $0x2,%rsi
cmp    %esi,%edx
jne    2060 <cvJacobiEigens_32f+0xf30>
jmp    1ed0 <cvJacobiEigens_32f+0xda0>
cmpq   $0x0,0x80(%rsp)
je     217f <cvJacobiEigens_32f+0x104f>
mov    0x98(%rsp),%rdx
lea    (%rdx,%r8,4),%rsi
lea    (%rdx,%rcx,4),%rdi
mov    0xa0(%rsp),%rbp
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups -0x30(%rsi,%rdx,4),%xmm0
movups -0x20(%rsi,%rdx,4),%xmm1
movups -0x30(%rdi,%rdx,4),%xmm2
movups -0x20(%rdi,%rdx,4),%xmm3
movups %xmm2,-0x30(%rsi,%rdx,4)
movups %xmm3,-0x20(%rsi,%rdx,4)
movups %xmm0,-0x30(%rdi,%rdx,4)
movups %xmm1,-0x20(%rdi,%rdx,4)
movups -0x10(%rsi,%rdx,4),%xmm0
movups (%rsi,%rdx,4),%xmm1
movupd -0x10(%rdi,%rdx,4),%xmm2
movups (%rdi,%rdx,4),%xmm3
movupd %xmm2,-0x10(%rsi,%rdx,4)
movups %xmm3,(%rsi,%rdx,4)
movups %xmm0,-0x10(%rdi,%rdx,4)
movups %xmm1,(%rdi,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rbp
jne    20d0 <cvJacobiEigens_32f+0xfa0>
testb  $0x1,0xa8(%rsp)
01
je     215f <cvJacobiEigens_32f+0x102f>
lea    (%rdx,%r8,1),%rsi
add    %rcx,%rdx
movups (%rax,%rsi,4),%xmm0
movups 0x10(%rax,%rsi,4),%xmm1
movupd (%rax,%rdx,4),%xmm2
movups 0x10(%rax,%rdx,4),%xmm3
movupd %xmm2,(%rax,%rsi,4)
movups %xmm3,0x10(%rax,%rsi,4)
movups %xmm0,(%rax,%rdx,4)
movups %xmm1,0x10(%rax,%rdx,4)
mov    0x58(%rsp),%rax
cmp    %rax,0x28(%rsp)
je     1ed0 <cvJacobiEigens_32f+0xda0>
mov    0x58(%rsp),%rdx
add    %rdx,%r8
add    %rdx,%rcx
jmp    1fae <cvJacobiEigens_32f+0xe7e>
xor    %edx,%edx
testb  $0x1,0xa8(%rsp)
01
jne    2132 <cvJacobiEigens_32f+0x1002>
jmp    215f <cvJacobiEigens_32f+0x102f>
xor    %eax,%eax
add    $0x118,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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