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

/* Forward declarations */

/* Type definitions */

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


x86 assembly (clang, -O0):
<cvJacobiEigens_32f>:
push   %rbp
mov    %rsp,%rbp
sub    $0x140,%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  0xeb1(%rip),%xmm0
ucomiss -0x20(%rbp),%xmm0
jbe    1166 <cvJacobiEigens_32f+0x56>
movss  0xe9f(%rip),%xmm0
movss  %xmm0,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    124a <cvJacobiEigens_32f+0x13a>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    11cc <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    1180 <cvJacobiEigens_32f+0x70>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    11fd <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    11d3 <cvJacobiEigens_32f+0xc3>
mov    -0x40(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  0xdf7(%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    116d <cvJacobiEigens_32f+0x5d>
movsd  -0x50(%rbp),%xmm0
addsd  -0x50(%rbp),%xmm0
call   1030 <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    1c32 <cvJacobiEigens_32f+0xb22>
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    1c06 <cvJacobiEigens_32f+0xaf6>
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    1bce <cvJacobiEigens_32f+0xabe>
mov    -0x78(%rbp),%rax
movslq -0x68(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xcc(%rbp)
ff
movss  -0xcc(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movaps 0xcba(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  -0xf0(%rbp),%xmm1
ff
movsd  -0x48(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    137e <cvJacobiEigens_32f+0x26e>
jmp    1b90 <cvJacobiEigens_32f+0xa80>
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  0xc55(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movss  -0xcc(%rbp),%xmm0
ff
mulss  -0xcc(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0x98(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1030 <sqrt@plt>
movsd  %xmm0,-0xf8(%rbp)
ff
movss  -0xcc(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
cvtss2sd %xmm0,%xmm0
divsd  -0xf8(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
xorps  %xmm0,%xmm0
ucomisd -0x98(%rbp),%xmm0
ff
jbe    1471 <cvJacobiEigens_32f+0x361>
movsd  -0x90(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0x90(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm1,%xmm0
movsd  0xb8c(%rip),%xmm1
addsd  %xmm1,%xmm0
call   1030 <sqrt@plt>
movsd  %xmm0,-0x100(%rbp)
ff
movsd  0xb73(%rip),%xmm1
addsd  -0x100(%rbp),%xmm1
ff
movsd  0xb5b(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <sqrt@plt>
movsd  %xmm0,-0x108(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
divsd  -0x108(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
mulsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  0xb1a(%rip),%xmm0
subsd  -0xb8(%rbp),%xmm0
ff
call   1030 <sqrt@plt>
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
mulsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
movss  -0xcc(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movsd  0xad1(%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    1752 <cvJacobiEigens_32f+0x642>
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
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    1585 <cvJacobiEigens_32f+0x475>
jmp    1757 <cvJacobiEigens_32f+0x647>
mov    -0x24(%rbp),%eax
cmp    -0x68(%rbp),%eax
jge    191e <cvJacobiEigens_32f+0x80e>
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    1757 <cvJacobiEigens_32f+0x647>
jmp    1923 <cvJacobiEigens_32f+0x813>
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1ac9 <cvJacobiEigens_32f+0x9b9>
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
ff
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    1923 <cvJacobiEigens_32f+0x813>
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
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)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x10c(%rbp)
ff
movss  -0x10c(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movslq -0x64(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x10c(%rbp),%xmm0
ff
mov    -0x78(%rbp),%rax
movslq -0x68(%rbp),%rcx
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    1322 <cvJacobiEigens_32f+0x212>
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    12c9 <cvJacobiEigens_32f+0x1b9>
cmpl   $0x0,-0x30(%rbp)
jne    1c15 <cvJacobiEigens_32f+0xb05>
jmp    1c1a <cvJacobiEigens_32f+0xb0a>
jmp    12ab <cvJacobiEigens_32f+0x19b>
cvtsi2sdl -0x1c(%rbp),%xmm1
movsd  -0x48(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
jmp    1288 <cvJacobiEigens_32f+0x178>
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1c80 <cvJacobiEigens_32f+0xb70>
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    1c40 <cvJacobiEigens_32f+0xb30>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1ea9 <cvJacobiEigens_32f+0xd99>
mov    -0x24(%rbp),%eax
mov    %eax,-0x110(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movaps 0x35c(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0x120(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x114(%rbp)
ff
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1da0 <cvJacobiEigens_32f+0xc90>
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movaps 0x30f(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x130(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x124(%rbp)
ff
movss  -0x114(%rbp),%xmm1
ff
movss  -0x124(%rbp),%xmm0
ff
ucomiss %xmm1,%xmm0
jbe    1d48 <cvJacobiEigens_32f+0xc38>
mov    -0x28(%rbp),%eax
mov    %eax,-0x110(%rbp)
jmp    1d54 <cvJacobiEigens_32f+0xc44>
mov    -0x110(%rbp),%eax
mov    %eax,-0x110(%rbp)
movss  -0x114(%rbp),%xmm1
ff
movss  -0x124(%rbp),%xmm0
ff
ucomiss %xmm1,%xmm0
jbe    1d82 <cvJacobiEigens_32f+0xc72>
movss  -0x124(%rbp),%xmm0
ff
movss  %xmm0,-0x114(%rbp)
ff
jmp    1d92 <cvJacobiEigens_32f+0xc82>
movss  -0x114(%rbp),%xmm0
ff
movss  %xmm0,-0x114(%rbp)
ff
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1cdd <cvJacobiEigens_32f+0xbcd>
mov    -0x110(%rbp),%eax
cmp    -0x24(%rbp),%eax
je     1e9b <cvJacobiEigens_32f+0xd8b>
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x138(%rbp)
ff
mov    -0x18(%rbp),%rax
movslq -0x110(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x138(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x110(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movl   $0x0,-0x28(%rbp)
mov    -0x24(%rbp),%eax
imul   -0x1c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x110(%rbp),%eax
imul   -0x1c(%rbp),%eax
mov    %eax,-0x134(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1e96 <cvJacobiEigens_32f+0xd86>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x138(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x134(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x138(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x134(%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    -0x134(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x134(%rbp)
jmp    1e1a <cvJacobiEigens_32f+0xd0a>
jmp    1e9b <cvJacobiEigens_32f+0xd8b>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1c87 <cvJacobiEigens_32f+0xb77>
xor    %eax,%eax
add    $0x140,%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,0x20(%rsp)
mov    %rdx,%r15
mov    %rsi,0x30(%rsp)
movss  0x1eb9(%rip),%xmm0
movss  %xmm0,0x10(%rsp)
mov    %ecx,%eax
xorpd  %xmm2,%xmm2
mov    %rcx,0x8(%rsp)
test   %ecx,%ecx
mov    %rax,0x58(%rsp)
mov    %rdi,0x28(%rsp)
jle    128f <cvJacobiEigens_32f+0x16f>
lea    0x0(,%rax,4),%r13
xorpd  %xmm2,%xmm2
xor    %ebx,%ebx
mov    %rdi,%rbp
mov    0x30(%rsp),%r14
jmp    11cf <cvJacobiEigens_32f+0xaf>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  %xmm2,0x40(%rsp)
mov    %r14,%rdi
xor    %esi,%esi
mov    %r13,%rdx
call   1030 <memset@plt>
movsd  0x40(%rsp),%xmm2
movl   $0x3f800000,(%r14,%rbx,4)
3f
add    $0x1,%rbx
mov    0x58(%rsp),%rax
lea    (%r14,%rax,4),%r14
add    %r13,%rbp
cmp    %rax,%rbx
mov    0x28(%rsp),%rdi
je     128f <cvJacobiEigens_32f+0x16f>
test   %rbx,%rbx
je     1190 <cvJacobiEigens_32f+0x70>
lea    -0x1(%rbx),%rax
cmp    $0x3,%rax
jae    11f0 <cvJacobiEigens_32f+0xd0>
xor    %eax,%eax
jmp    1254 <cvJacobiEigens_32f+0x134>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%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+0xe0>
test   $0x3,%bl
je     1190 <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+0x150>
jmp    1190 <cvJacobiEigens_32f+0x70>
movss  0x10(%rsp),%xmm0
maxss  0x20(%rsp),%xmm0
movss  %xmm0,0x10(%rsp)
addsd  %xmm2,%xmm2
ucomisd 0x1db3(%rip),%xmm2
mov    %r15,0x68(%rsp)
jb     12bb <cvJacobiEigens_32f+0x19b>
sqrtsd %xmm2,%xmm14
jmp    12d3 <cvJacobiEigens_32f+0x1b3>
movapd %xmm2,%xmm0
call   1040 <sqrt@plt>
mov    0x28(%rsp),%rdi
mov    0x58(%rsp),%rax
movapd %xmm0,%xmm14
mov    0x8(%rsp),%rbp
mov    0x30(%rsp),%r8
movss  0x10(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
cvtsi2sd %ebp,%xmm1
mulsd  %xmm14,%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0xd0(%rsp)
ucomisd %xmm0,%xmm14
jbe    1cb8 <cvJacobiEigens_32f+0xb98>
movapd %xmm1,%xmm0
movabs $0x1fffffff8,%rdx
lea    -0x1(%rbp),%ecx
mov    %rcx,0xe0(%rsp)
movslq %ebp,%r10
lea    0x1(%r10),%rcx
mov    %rcx,0xd8(%rsp)
lea    0x0(,%r10,4),%rsi
movaps 0x1ccd(%rip),%xmm15
add    $0x4,%rdx
mov    %rdx,0xe8(%rsp)
mov    %r10,0xa0(%rsp)
mov    %rsi,0x38(%rsp)
movsd  %xmm1,0xc8(%rsp)
jmp    1393 <cvJacobiEigens_32f+0x273>
nopw   0x0(%rax,%rax,1)
movsd  0xc8(%rsp),%xmm0
divsd  %xmm0,%xmm14
ucomisd 0xd0(%rsp),%xmm14
mov    0x8(%rsp),%rbp
jbe    1cb8 <cvJacobiEigens_32f+0xb98>
divsd  %xmm0,%xmm14
cmp    $0x2,%ebp
jl     1370 <cvJacobiEigens_32f+0x250>
xor    %r15d,%r15d
mov    $0x1,%ecx
xor    %r9d,%r9d
mov    %r8,%r13
mov    %rdi,%r12
movsd  %xmm14,0xa8(%rsp)
nopl   0x0(%rax,%rax,1)
mov    %rcx,0x98(%rsp)
lea    0x1(%r15),%rbp
cmp    %r10,%rbp
mov    %rbp,0xf0(%rsp)
jge    1c50 <cvJacobiEigens_32f+0xb30>
mov    %r15,%rcx
imul   %r10,%rcx
lea    (%rdi,%rcx,4),%rdx
add    $0x4,%rdx
mov    %rdx,0x108(%rsp)
mov    0xd8(%rsp),%rdx
add    %rcx,%rdx
mov    %rdx,0x100(%rsp)
lea    (%r8,%rcx,4),%rcx
add    $0x4,%rcx
mov    %rcx,0xf8(%rsp)
mov    %rbp,%rcx
imul   %r10,%rcx
lea    (%r8,%rcx,4),%r14
lea    (%rdi,%rcx,4),%rbx
mov    0x98(%rsp),%rcx
lea    0x0(,%rcx,4),%rbp
xor    %r10d,%r10d
mov    %rcx,%rdx
jmp    14fb <cvJacobiEigens_32f+0x3db>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movapd 0xb0(%rsp),%xmm5
addsd  %xmm5,%xmm5
mulsd  %xmm0,%xmm5
mulsd  %xmm0,%xmm0
mulsd  %xmm7,%xmm5
movss  0x88(%rsp),%xmm1
cvtss2sd %xmm1,%xmm1
movss  0x94(%rsp),%xmm2
cvtss2sd %xmm2,%xmm2
movapd %xmm9,%xmm3
mulsd  %xmm2,%xmm3
movaps %xmm1,%xmm4
mulsd  %xmm0,%xmm4
addsd  %xmm3,%xmm4
subsd  %xmm5,%xmm4
xorps  %xmm3,%xmm3
cvtsd2ss %xmm4,%xmm3
movss  %xmm3,(%r12,%r15,4)
mulsd  %xmm2,%xmm0
mulsd  %xmm9,%xmm1
addsd  %xmm0,%xmm1
addsd  %xmm5,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
movss  %xmm0,(%rbx,%rdx,4)
movl   $0x0,(%rbx,%r15,4)
movl   $0x0,(%r12,%rdx,4)
mov    $0x1,%r9d
mov    0x58(%rsp),%rax
add    $0x1,%rdx
add    %rsi,%rbx
add    %rsi,%r14
add    $0x1,%r10
add    $0x4,%rbp
cmp    %rax,%rdx
je     1c50 <cvJacobiEigens_32f+0xb30>
movss  (%r12,%rdx,4),%xmm5
xorps  %xmm2,%xmm2
cvtss2sd %xmm5,%xmm2
movaps %xmm2,%xmm0
andps  %xmm15,%xmm0
ucomisd %xmm0,%xmm14
ja     14e0 <cvJacobiEigens_32f+0x3c0>
movss  (%r12,%r15,4),%xmm3
movss  (%rbx,%rdx,4),%xmm4
movaps %xmm3,%xmm0
subss  %xmm4,%xmm0
xorps  %xmm6,%xmm6
cvtss2sd %xmm0,%xmm6
mulsd  0x1b19(%rip),%xmm6
movaps %xmm5,%xmm0
mulss  %xmm5,%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm0,%xmm1
movapd %xmm6,%xmm0
mulsd  %xmm6,%xmm0
addsd  %xmm1,%xmm0
ucomisd 0x1b07(%rip),%xmm0
mov    %r10,0x10(%rsp)
mov    %rdx,0x20(%rsp)
movaps %xmm2,0xb0(%rsp)
movss  %xmm3,0x88(%rsp)
movss  %xmm4,0x94(%rsp)
jb     1590 <cvJacobiEigens_32f+0x470>
sqrtsd %xmm0,%xmm0
jmp    15ab <cvJacobiEigens_32f+0x48b>
cs nopw 0x0(%rax,%rax,1)
nop
movaps %xmm5,0x40(%rsp)
movapd %xmm6,0x70(%rsp)
call   1040 <sqrt@plt>
movapd 0x70(%rsp),%xmm6
movaps 0x40(%rsp),%xmm5
xorps  0x1a6e(%rip),%xmm5
xorps  %xmm3,%xmm3
cvtss2sd %xmm5,%xmm3
divsd  %xmm0,%xmm3
xorps  %xmm2,%xmm2
cmpltsd %xmm2,%xmm6
movapd %xmm6,%xmm0
andnpd %xmm3,%xmm0
xorpd  0x1a5b(%rip),%xmm3
andpd  %xmm6,%xmm3
orpd   %xmm0,%xmm3
movapd %xmm3,%xmm1
mulsd  %xmm3,%xmm1
movsd  0x1a6b(%rip),%xmm0
subsd  %xmm1,%xmm0
ucomisd %xmm2,%xmm0
movapd %xmm3,0x40(%rsp)
jb     1610 <cvJacobiEigens_32f+0x4f0>
sqrtsd %xmm0,%xmm0
jmp    1615 <cvJacobiEigens_32f+0x4f5>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
call   1040 <sqrt@plt>
addsd  0x1a3b(%rip),%xmm0
addsd  %xmm0,%xmm0
ucomisd 0x1a37(%rip),%xmm0
jb     1640 <cvJacobiEigens_32f+0x520>
sqrtsd %xmm0,%xmm0
jmp    1645 <cvJacobiEigens_32f+0x525>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
call   1040 <sqrt@plt>
movapd 0x40(%rsp),%xmm7
divsd  %xmm0,%xmm7
movapd %xmm7,%xmm9
mulsd  %xmm7,%xmm9
movsd  0x19f7(%rip),%xmm0
subsd  %xmm9,%xmm0
ucomisd 0x19f2(%rip),%xmm0
jb     1680 <cvJacobiEigens_32f+0x560>
sqrtsd %xmm0,%xmm0
jmp    169f <cvJacobiEigens_32f+0x57f>
cs nopw 0x0(%rax,%rax,1)
movapd %xmm7,0x40(%rsp)
movapd %xmm9,0x70(%rsp)
call   1040 <sqrt@plt>
movapd 0x70(%rsp),%xmm9
movapd 0x40(%rsp),%xmm7
mov    0x28(%rsp),%rdi
movsd  0xa8(%rsp),%xmm14
mov    0x38(%rsp),%rsi
movaps 0x1955(%rip),%xmm15
mov    0x10(%rsp),%r10
mov    0x20(%rsp),%rdx
mov    0x8(%rsp),%r9
test   %r15,%r15
je     17a1 <cvJacobiEigens_32f+0x681>
movapd %xmm7,%xmm1
xorpd  0x1951(%rip),%xmm1
mov    %rdi,%rax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
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    %rsi,%rax
cmp    %rcx,%r15
jne    16f0 <cvJacobiEigens_32f+0x5d0>
mov    %r15d,%r8d
jmp    17a7 <cvJacobiEigens_32f+0x687>
xor    %r8d,%r8d
mov    %rdi,%rax
mov    %r8d,%ecx
cmp    %rcx,%rdx
jbe    187d <cvJacobiEigens_32f+0x75d>
movapd %xmm7,%xmm1
xorpd  0x1871(%rip),%xmm1
lea    (%rax,%rdx,4),%rax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
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    %rsi,%rax
cmp    %rcx,%rdx
jne    17d0 <cvJacobiEigens_32f+0x6b0>
mov    %edx,%r8d
cmp    %r9d,%r8d
jge    1450 <cvJacobiEigens_32f+0x330>
movapd %xmm7,%xmm8
xorpd  0x179c(%rip),%xmm8
mov    %r8d,%eax
not    %r8d
add    %r9d,%r8d
cmp    $0x3,%r8d
jb     1b80 <cvJacobiEigens_32f+0xa60>
mov    %r10,%rcx
imul   0xa0(%rsp),%rcx
add    0x100(%rsp),%rcx
lea    (%rdi,%rcx,4),%r9
mov    0x30(%rsp),%rdx
lea    (%rdx,%rcx,4),%rcx
mov    %rcx,0x40(%rsp)
lea    (%r12,%rax,4),%rdx
lea    (%r8,%rax,1),%rsi
mov    0x108(%rsp),%rcx
lea    (%rcx,%rsi,4),%rdi
mov    %rbx,0x60(%rsp)
lea    (%rbx,%rax,4),%r10
lea    (%r9,%rsi,4),%r9
lea    0x0(%r13,%rax,4),%r11
mov    0xf8(%rsp),%rcx
lea    (%rcx,%rsi,4),%rcx
mov    %rcx,0x110(%rsp)
lea    (%r14,%rax,4),%rcx
mov    0x40(%rsp),%rbx
lea    (%rbx,%rsi,4),%rbx
cmp    %r9,%rdx
setb   0x40(%rsp)
cmp    %rdi,%r10
setb   0x70(%rsp)
mov    0x110(%rsp),%rsi
cmp    %rsi,%rdx
setb   0x1f(%rsp)
cmp    %rdi,%r11
setb   0x1e(%rsp)
cmp    %rbx,%rdx
setb   0x1d(%rsp)
cmp    %rdi,%rcx
setb   0x1c(%rsp)
cmp    %rsi,%r10
setb   %dil
cmp    %r9,%r11
setb   0x1b(%rsp)
cmp    %rbx,%r10
setb   0x1a(%rsp)
cmp    %r9,%rcx
setb   0x19(%rsp)
cmp    %rbx,%r11
setb   %r9b
cmp    %rsi,%rcx
setb   %sil
mov    0x70(%rsp),%bl
test   %bl,0x40(%rsp)
jne    1c2d <cvJacobiEigens_32f+0xb0d>
mov    %sil,0x40(%rsp)
mov    %r9d,%esi
mov    0x1e(%rsp),%bl
and    %bl,0x1f(%rsp)
mov    0x8(%rsp),%r9
jne    1b5b <cvJacobiEigens_32f+0xa3b>
mov    0x1c(%rsp),%bl
and    %bl,0x1d(%rsp)
jne    1b5b <cvJacobiEigens_32f+0xa3b>
and    0x1b(%rsp),%dil
jne    1b5b <cvJacobiEigens_32f+0xa3b>
mov    0x19(%rsp),%bl
and    %bl,0x1a(%rsp)
jne    1b5b <cvJacobiEigens_32f+0xa3b>
and    0x40(%rsp),%sil
jne    1b5b <cvJacobiEigens_32f+0xa3b>
movapd %xmm9,0x70(%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,0x40(%rsp)
movapd %xmm7,%xmm10
unpcklpd %xmm7,%xmm10
xor    %ebx,%ebx
mov    0x38(%rsp),%rsi
mov    0x28(%rsp),%rdi
nopl   (%rax)
cvtps2pd 0x8(%rdx,%rbx,4),%xmm1
cvtps2pd (%rdx,%rbx,4),%xmm13
cvtps2pd (%r10,%rbx,4),%xmm7
cvtps2pd 0x8(%r10,%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(%r11,%rbx,4),%xmm2
cvtps2pd (%r11,%rbx,4),%xmm1
cvtps2pd (%rcx,%rbx,4),%xmm5
cvtps2pd 0x8(%rcx,%rbx,4),%xmm6
movupd %xmm3,(%rdx,%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,(%r10,%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,(%r11,%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    1a20 <cvJacobiEigens_32f+0x900>
cmp    %r9,%r8
mov    0x8(%rsp),%r9
mov    0x60(%rsp),%rbx
mov    0x10(%rsp),%r10
mov    0x20(%rsp),%rdx
movapd 0x40(%rsp),%xmm7
movapd 0x70(%rsp),%xmm9
jne    1b80 <cvJacobiEigens_32f+0xa60>
jmp    1450 <cvJacobiEigens_32f+0x330>
mov    0x38(%rsp),%rsi
mov    0x60(%rsp),%rbx
mov    0x10(%rsp),%r10
mov    0x20(%rsp),%rdx
mov    0x28(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%r12,%rax,4),%xmm1
movss  (%rbx,%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,(%rbx,%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    %r9d,%eax
jl     1b80 <cvJacobiEigens_32f+0xa60>
jmp    1450 <cvJacobiEigens_32f+0x330>
mov    0x8(%rsp),%r9
mov    0x28(%rsp),%rdi
mov    0x38(%rsp),%rsi
mov    0x60(%rsp),%rbx
mov    0x10(%rsp),%r10
mov    0x20(%rsp),%rdx
jmp    1b80 <cvJacobiEigens_32f+0xa60>
mov    0xa0(%rsp),%r10
lea    (%r12,%r10,4),%r12
lea    0x0(%r13,%r10,4),%r13
mov    0x98(%rsp),%rcx
add    $0x1,%rcx
mov    0xf0(%rsp),%rdx
mov    %rdx,%r15
cmp    0xe0(%rsp),%rdx
mov    0x30(%rsp),%r8
jne    13c0 <cvJacobiEigens_32f+0x2a0>
cmpl   $0x2,0x8(%rsp)
jl     1370 <cvJacobiEigens_32f+0x250>
xor    %r15d,%r15d
mov    $0x1,%ecx
mov    %r8,%r13
mov    %rdi,%r12
test   %r9d,%r9d
mov    $0x0,%r9d
jne    13c0 <cvJacobiEigens_32f+0x2a0>
jmp    1370 <cvJacobiEigens_32f+0x250>
test   %ebp,%ebp
mov    0x68(%rsp),%r15
jle    2166 <cvJacobiEigens_32f+0x1046>
lea    0x1(%rbp),%eax
movslq %eax,%r10
cmp    $0x8,%ebp
jae    1cde <cvJacobiEigens_32f+0xbbe>
xor    %ecx,%ecx
xor    %edx,%edx
mov    0x58(%rsp),%r8
jmp    1dd5 <cvJacobiEigens_32f+0xcb5>
mov    0x58(%rsp),%r8
lea    -0x1(%r8),%rcx
imul   %r10,%rcx
lea    (%rdi,%rcx,4),%rdx
cmp    %rdi,%rdx
mov    %rdx,%rcx
cmova  %rdi,%rcx
cmovb  %rdi,%rdx
add    $0x4,%rdx
cmp    %r15,%rdx
jbe    1d18 <cvJacobiEigens_32f+0xbf8>
lea    (%r15,%r8,4),%rdx
cmp    %rdx,%rcx
jae    1d18 <cvJacobiEigens_32f+0xbf8>
xor    %ecx,%ecx
xor    %edx,%edx
jmp    1dd5 <cvJacobiEigens_32f+0xcb5>
mov    %r8d,%edx
and    $0xfffffff8,%edx
mov    %rdx,%rcx
imul   %r10,%rcx
lea    0x0(,%r10,4),%r11
lea    0x0(,%r8,4),%r8
and    $0xffffffffffffffe0,%r8
mov    %r10,%r9
shl    $0x5,%r9
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%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,(%r15,%rbx,1)
movupd %xmm0,0x10(%r15,%rbx,1)
add    $0x20,%rbx
add    %r9,%rdi
cmp    %rbx,%r8
jne    1d50 <cvJacobiEigens_32f+0xc30>
mov    0x58(%rsp),%r8
cmp    %r8,%rdx
mov    0x28(%rsp),%rdi
je     1e6c <cvJacobiEigens_32f+0xd4c>
mov    %rdx,%rsi
not    %rsi
add    %r8,%rsi
mov    %r8,%rax
and    $0x3,%rax
je     1e08 <cvJacobiEigens_32f+0xce8>
nopw   0x0(%rax,%rax,1)
movss  (%rdi,%rcx,4),%xmm0
movss  %xmm0,(%r15,%rdx,4)
add    $0x1,%rdx
add    %r10,%rcx
add    $0xffffffffffffffff,%rax
jne    1df0 <cvJacobiEigens_32f+0xcd0>
cmp    $0x3,%rsi
jb     1e6c <cvJacobiEigens_32f+0xd4c>
lea    0x0(,%rcx,4),%r9
mov    %r10,%rsi
shl    $0x4,%rsi
lea    (%r10,%r10,2),%rax
lea    (%r9,%rax,4),%rbp
lea    (%r9,%r10,8),%rbx
add    %r10,%rcx
nopl   0x0(%rax)
movss  (%rdi,%r9,1),%xmm0
movss  %xmm0,(%r15,%rdx,4)
movss  (%rdi,%rcx,4),%xmm0
movss  %xmm0,0x4(%r15,%rdx,4)
movss  (%rdi,%rbx,1),%xmm0
movss  %xmm0,0x8(%r15,%rdx,4)
movss  (%rdi,%rbp,1),%xmm0
movss  %xmm0,0xc(%r15,%rdx,4)
add    $0x4,%rdx
add    %rsi,%rdi
cmp    %rdx,%r8
jne    1e30 <cvJacobiEigens_32f+0xd10>
mov    0x8(%rsp),%rax
test   %eax,%eax
jle    2166 <cvJacobiEigens_32f+0x1046>
mov    %r8,%rbx
lea    -0x1(%rax),%r10d
mov    0x30(%rsp),%rcx
lea    (%rcx,%r10,4),%r12
add    $0x4,%r12
lea    0x1(%r10),%r9
mov    %r9,0x40(%rsp)
and    $0xfffffffffffffff8,%r9
lea    -0x8(%r9),%rdx
mov    %rdx,0x10(%rsp)
mov    %rdx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %rsi,%rdx
mov    %rsi,0x20(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,0xb0(%rsp)
mov    %eax,%r8d
neg    %r8d
lea    0x30(%rcx),%rax
mov    %rax,0x88(%rsp)
lea    0x4(%rcx),%r13
mov    $0x1,%edx
xor    %edi,%edi
movaps 0x115a(%rip),%xmm0
xor    %esi,%esi
jmp    1f06 <cvJacobiEigens_32f+0xde6>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rdx
add    0x8(%rsp),%esi
mov    0x58(%rsp),%rbx
cmp    %rbx,%rdi
je     2166 <cvJacobiEigens_32f+0x1046>
mov    %rdi,%rbp
movss  (%r15,%rdi,4),%xmm1
add    $0x1,%rdi
cmp    %rbx,%rdi
jae    1f60 <cvJacobiEigens_32f+0xe40>
movaps %xmm1,%xmm2
andps  %xmm0,%xmm2
mov    %rdx,%rax
mov    %ebp,%ebx
mov    0x58(%rsp),%rcx
nopl   0x0(%rax,%rax,1)
movss  (%r15,%rax,4),%xmm3
andps  %xmm0,%xmm3
ucomiss %xmm2,%xmm3
cmova  %eax,%ebx
maxss  %xmm2,%xmm3
add    $0x1,%rax
movaps %xmm3,%xmm2
cmp    %rax,%rcx
jne    1f30 <cvJacobiEigens_32f+0xe10>
jmp    1f62 <cvJacobiEigens_32f+0xe42>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %ebp,%ebx
mov    %ebx,%eax
cmp    %rax,%rbp
je     1ef0 <cvJacobiEigens_32f+0xdd0>
movslq %esi,%r11
movslq %ebx,%rax
imul   0x8(%rsp),%ebx
mov    %r15,%rcx
xor    %r15d,%r15d
movss  (%rcx,%rax,4),%xmm2
movss  %xmm2,(%rcx,%rbp,4)
movss  %xmm1,(%rcx,%rax,4)
movslq %ebx,%r14
cmp    $0x7,%r10d
jae    1fa0 <cvJacobiEigens_32f+0xe80>
mov    0x8(%rsp),%rax
mov    0x30(%rsp),%rbx
jmp    1fcc <cvJacobiEigens_32f+0xeac>
xchg   %ax,%ax
mov    0x30(%rsp),%rbx
lea    (%rbx,%r11,4),%rax
lea    (%r12,%r14,4),%rcx
cmp    %rcx,%rax
jae    2079 <cvJacobiEigens_32f+0xf59>
lea    (%r12,%r11,4),%rax
lea    (%rbx,%r14,4),%rcx
cmp    %rax,%rcx
jae    2079 <cvJacobiEigens_32f+0xf59>
mov    0x8(%rsp),%rax
sub    %r15d,%eax
test   $0x1,%al
jne    1fe0 <cvJacobiEigens_32f+0xec0>
mov    %r15d,%ebx
jmp    2004 <cvJacobiEigens_32f+0xee4>
nopl   0x0(%rax,%rax,1)
movss  (%rbx,%r11,4),%xmm1
movss  (%rbx,%r14,4),%xmm2
movss  %xmm2,(%rbx,%r11,4)
movss  %xmm1,(%rbx,%r14,4)
lea    0x1(%r15),%ebx
add    $0x1,%r11
add    $0x1,%r14
not    %r15d
cmp    %r8d,%r15d
mov    0x68(%rsp),%r15
je     1ef0 <cvJacobiEigens_32f+0xdd0>
lea    0x0(,%r11,4),%rax
add    %r13,%rax
lea    0x0(,%r14,4),%rcx
add    %r13,%rcx
mov    0x8(%rsp),%rbp
sub    %ebx,%ebp
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  -0x4(%rax,%rbx,4),%xmm1
movss  -0x4(%rcx,%rbx,4),%xmm2
movss  %xmm2,-0x4(%rax,%rbx,4)
movss  %xmm1,-0x4(%rcx,%rbx,4)
movss  (%rax,%rbx,4),%xmm1
movss  (%rcx,%rbx,4),%xmm2
movss  %xmm2,(%rax,%rbx,4)
movss  %xmm1,(%rcx,%rbx,4)
add    $0x2,%rbx
cmp    %ebx,%ebp
jne    2040 <cvJacobiEigens_32f+0xf20>
jmp    1ef0 <cvJacobiEigens_32f+0xdd0>
cmpq   $0x0,0x10(%rsp)
je     2156 <cvJacobiEigens_32f+0x1036>
mov    0x88(%rsp),%rcx
lea    (%rcx,%r11,4),%rax
lea    (%rcx,%r14,4),%rcx
mov    0xb0(%rsp),%rbp
xor    %ebx,%ebx
mov    0x68(%rsp),%r15
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups -0x30(%rax,%rbx,4),%xmm1
movups -0x20(%rax,%rbx,4),%xmm2
movups -0x30(%rcx,%rbx,4),%xmm3
movups -0x20(%rcx,%rbx,4),%xmm4
movups %xmm3,-0x30(%rax,%rbx,4)
movups %xmm4,-0x20(%rax,%rbx,4)
movups %xmm1,-0x30(%rcx,%rbx,4)
movups %xmm2,-0x20(%rcx,%rbx,4)
movups -0x10(%rax,%rbx,4),%xmm1
movups (%rax,%rbx,4),%xmm2
movups -0x10(%rcx,%rbx,4),%xmm3
movups (%rcx,%rbx,4),%xmm4
movups %xmm3,-0x10(%rax,%rbx,4)
movups %xmm4,(%rax,%rbx,4)
movups %xmm1,-0x10(%rcx,%rbx,4)
movups %xmm2,(%rcx,%rbx,4)
add    $0x10,%rbx
add    $0xfffffffffffffffe,%rbp
jne    20b0 <cvJacobiEigens_32f+0xf90>
testb  $0x1,0x20(%rsp)
je     213d <cvJacobiEigens_32f+0x101d>
lea    (%rbx,%r11,1),%rax
add    %r14,%rbx
mov    0x30(%rsp),%rcx
movups (%rcx,%rax,4),%xmm1
movups 0x10(%rcx,%rax,4),%xmm2
movups (%rcx,%rbx,4),%xmm3
movups 0x10(%rcx,%rbx,4),%xmm4
movups %xmm3,(%rcx,%rax,4)
movups %xmm4,0x10(%rcx,%rax,4)
movups %xmm1,(%rcx,%rbx,4)
movups %xmm2,0x10(%rcx,%rbx,4)
cmp    %r9,0x40(%rsp)
je     1ef0 <cvJacobiEigens_32f+0xdd0>
add    %r9,%r11
add    %r9,%r14
mov    %r9d,%r15d
jmp    1f92 <cvJacobiEigens_32f+0xe72>
xor    %ebx,%ebx
mov    0x68(%rsp),%r15
testb  $0x1,0x20(%rsp)
jne    210d <cvJacobiEigens_32f+0xfed>
jmp    213d <cvJacobiEigens_32f+0x101d>
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 double
%43 = alloca double
%44 = alloca double
%45 = alloca double
%46 = alloca float
%47 = alloca i32
%48 = alloca float
%49 = alloca double
%50 = alloca float
%51 = alloca double
%52 = alloca i32
%53 = 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
%54 = load float*, float** %6
store float* %54, float** %15
%55 = load float*, float** %7
store float* %55, float** %16
store double 0.000000e+00, double* %18
%56 = load float, float* %10
%57 = fcmp olt float %56, 0x3E7AD7F2A0000000
br i1 %57, label %58, label %59
58: ; preds = %5
store float 0x3E7AD7F2A0000000, float* %10
br label %59
59: ; preds = %58, %5
store i32 0, i32* %11
br label %60
60: ; preds = %94, %59
%61 = load i32, i32* %11
%62 = load i32, i32* %9
%63 = icmp slt i32 %61, %62
br i1 %63, label %64, label %109
64: ; preds = %60
store i32 0, i32* %12
br label %65
65: ; preds = %69, %64
%66 = load i32, i32* %12
%67 = load i32, i32* %11
%68 = icmp slt i32 %66, %67
br i1 %68, label %69, label %82
69: ; preds = %65
%70 = load float*, float** %15
%71 = load i32, i32* %12
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds float, float* %70, i64 %72
%74 = load float, float* %73
%75 = fpext float %74 to double
store double %75, double* %20
%76 = load double, double* %20
%77 = load double, double* %20
%78 = load double, double* %18
%79 = call double @llvm.fmuladd.f64(double %76, double %77, double %78)
store double %79, double* %18
%80 = load i32, i32* %12
%81 = add nsw i32 %80, 1
store i32 %81, i32* %12
br label %65
82: ; preds = %65
store i32 0, i32* %12
br label %83
83: ; preds = %87, %82
%84 = load i32, i32* %12
%85 = load i32, i32* %9
%86 = icmp slt i32 %84, %85
br i1 %86, label %87, label %94
87: ; preds = %83
%88 = load float*, float** %16
%89 = load i32, i32* %12
%90 = sext i32 %89 to i64
%91 = getelementptr inbounds float, float* %88, i64 %90
store float 0.000000e+00, float* %91
%92 = load i32, i32* %12
%93 = add nsw i32 %92, 1
store i32 %93, i32* %12
br label %83
94: ; preds = %83
%95 = load float*, float** %16
%96 = load i32, i32* %11
%97 = sext i32 %96 to i64
%98 = getelementptr inbounds float, float* %95, i64 %97
store float 1.000000e+00, float* %98
%99 = load i32, i32* %11
%100 = add nsw i32 %99, 1
store i32 %100, i32* %11
%101 = load i32, i32* %9
%102 = load float*, float** %16
%103 = sext i32 %101 to i64
%104 = getelementptr inbounds float, float* %102, i64 %103
store float* %104, float** %16
%105 = load i32, i32* %9
%106 = load float*, float** %15
%107 = sext i32 %105 to i64
%108 = getelementptr inbounds float, float* %106, i64 %107
store float* %108, float** %15
br label %60
109: ; preds = %60
%110 = load double, double* %18
%111 = load double, double* %18
%112 = fadd double %110, %111
%113 = call double @sqrt(double %112)
store double %113, double* %18
%114 = load double, double* %18
%115 = load float, float* %10
%116 = fpext float %115 to double
%117 = fmul double %114, %116
%118 = load i32, i32* %9
%119 = sitofp i32 %118 to double
%120 = fdiv double %117, %119
store double %120, double* %19
%121 = load double, double* %18
store double %121, double* %17
br label %122
122: ; preds = %558, %109
%123 = load double, double* %17
%124 = load double, double* %19
%125 = fcmp ogt double %123, %124
br i1 %125, label %126, label %563
126: ; preds = %122
%127 = load i32, i32* %9
%128 = sitofp i32 %127 to double
%129 = load double, double* %17
%130 = fdiv double %129, %128
store double %130, double* %17
br label %131
131: ; preds = %126, %557
%132 = load float*, float** %7
store float* %132, float** %23
%133 = load float*, float** %6
store float* %133, float** %24
store i32 0, i32* %14
store i32 0, i32* %21
br label %134
134: ; preds = %542, %131
%135 = load i32, i32* %21
%136 = load i32, i32* %9
%137 = sub nsw i32 %136, 1
%138 = icmp slt i32 %135, %137
br i1 %138, label %139, label %553
139: ; preds = %134
%140 = load float*, float** %6
%141 = load i32, i32* %9
%142 = load i32, i32* %21
%143 = add nsw i32 %142, 1
%144 = mul nsw i32 %141, %143
%145 = sext i32 %144 to i64
%146 = getelementptr inbounds float, float* %140, i64 %145
store float* %146, float** %25
%147 = load float*, float** %7
%148 = load i32, i32* %9
%149 = load i32, i32* %21
%150 = add nsw i32 %149, 1
%151 = mul nsw i32 %148, %150
%152 = sext i32 %151 to i64
%153 = getelementptr inbounds float, float* %147, i64 %152
store float* %153, float** %26
%154 = load i32, i32* %21
%155 = add nsw i32 %154, 1
store i32 %155, i32* %22
br label %156
156: ; preds = %531, %139
%157 = load i32, i32* %22
%158 = load i32, i32* %9
%159 = icmp slt i32 %157, %158
br i1 %159, label %160, label %542
160: ; preds = %156
%161 = load float*, float** %24
%162 = load i32, i32* %22
%163 = sext i32 %162 to i64
%164 = getelementptr inbounds float, float* %161, i64 %163
%165 = load float, float* %164
store float %165, float* %35
%166 = load float, float* %35
%167 = fpext float %166 to double
%168 = call double @llvm.fabs.f64(double %167)
store double %168, double* %42
%169 = load double, double* %42
%170 = load double, double* %17
%171 = fcmp olt double %169, %170
br i1 %171, label %172, label %173
172: ; preds = %160
br label %531
173: ; preds = %160
store i32 1, i32* %14
%174 = load float*, float** %24
%175 = load i32, i32* %21
%176 = sext i32 %175 to i64
%177 = getelementptr inbounds float, float* %174, i64 %176
%178 = load float, float* %177
store float %178, float* %36
%179 = load float*, float** %25
%180 = load i32, i32* %22
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds float, float* %179, i64 %181
%183 = load float, float* %182
store float %183, float* %37
%184 = load float, float* %36
%185 = load float, float* %37
%186 = fsub float %184, %185
%187 = fpext float %186 to double
%188 = fmul double 5.000000e-01, %187
store double %188, double* %28
%189 = load float, float* %35
%190 = load float, float* %35
%191 = fmul float %189, %190
%192 = fpext float %191 to double
%193 = load double, double* %28
%194 = load double, double* %28
%195 = call double @llvm.fmuladd.f64(double %193, double %194, double %192)
%196 = call double @sqrt(double %195)
store double %196, double* %43
%197 = load float, float* %35
%198 = fneg float %197
%199 = fpext float %198 to double
%200 = load double, double* %43
%201 = fdiv double %199, %200
store double %201, double* %27
%202 = load double, double* %28
%203 = fcmp olt double %202, 0.000000e+00
br i1 %203, label %204, label %207
204: ; preds = %173
%205 = load double, double* %27
%206 = fneg double %205
store double %206, double* %27
br label %207
207: ; preds = %204, %173
%208 = load double, double* %27
%209 = load double, double* %27
%210 = fneg double %208
%211 = call double @llvm.fmuladd.f64(double %210, double %209, double 1.000000e+00)
%212 = call double @sqrt(double %211)
store double %212, double* %44
%213 = load double, double* %44
%214 = fadd double 1.000000e+00, %213
%215 = fmul double 2.000000e+00, %214
%216 = call double @sqrt(double %215)
store double %216, double* %45
%217 = load double, double* %27
%218 = load double, double* %45
%219 = fdiv double %217, %218
store double %219, double* %30
%220 = load double, double* %30
%221 = load double, double* %30
%222 = fmul double %220, %221
store double %222, double* %32
%223 = load double, double* %32
%224 = fsub double 1.000000e+00, %223
%225 = call double @sqrt(double %224)
store double %225, double* %29
%226 = load double, double* %29
%227 = load double, double* %29
%228 = fmul double %226, %227
store double %228, double* %31
%229 = load float, float* %35
%230 = fpext float %229 to double
%231 = fmul double 2.000000e+00, %230
%232 = load double, double* %29
%233 = fmul double %231, %232
%234 = load double, double* %30
%235 = fmul double %233, %234
store double %235, double* %33
%236 = load float*, float** %6
store float* %236, float** %34
store i32 0, i32* %11
br label %237
237: ; preds = %241, %207
%238 = load i32, i32* %11
%239 = load i32, i32* %21
%240 = icmp slt i32 %238, %239
br i1 %240, label %241, label %322
241: ; preds = %237
%242 = load float*, float** %34
%243 = load i32, i32* %21
%244 = sext i32 %243 to i64
%245 = getelementptr inbounds float, float* %242, i64 %244
%246 = load float, float* %245
store float %246, float* %38
%247 = load float*, float** %34
%248 = load i32, i32* %22
%249 = sext i32 %248 to i64
%250 = getelementptr inbounds float, float* %247, i64 %249
%251 = load float, float* %250
store float %251, float* %39
%252 = load float*, float** %23
%253 = load i32, i32* %11
%254 = sext i32 %253 to i64
%255 = getelementptr inbounds float, float* %252, i64 %254
%256 = load float, float* %255
store float %256, float* %40
%257 = load float*, float** %26
%258 = load i32, i32* %11
%259 = sext i32 %258 to i64
%260 = getelementptr inbounds float, float* %257, i64 %259
%261 = load float, float* %260
store float %261, float* %41
%262 = load float, float* %38
%263 = fpext float %262 to double
%264 = load double, double* %29
%265 = load float, float* %39
%266 = fpext float %265 to double
%267 = load double, double* %30
%268 = fmul double %266, %267
%269 = fneg double %268
%270 = call double @llvm.fmuladd.f64(double %263, double %264, double %269)
%271 = fptrunc double %270 to float
%272 = load float*, float** %34
%273 = load i32, i32* %21
%274 = sext i32 %273 to i64
%275 = getelementptr inbounds float, float* %272, i64 %274
store float %271, float* %275
%276 = load float, float* %39
%277 = fpext float %276 to double
%278 = load double, double* %29
%279 = load float, float* %38
%280 = fpext float %279 to double
%281 = load double, double* %30
%282 = fmul double %280, %281
%283 = call double @llvm.fmuladd.f64(double %277, double %278, double %282)
%284 = fptrunc double %283 to float
%285 = load float*, float** %34
%286 = load i32, i32* %22
%287 = sext i32 %286 to i64
%288 = getelementptr inbounds float, float* %285, i64 %287
store float %284, float* %288
%289 = load float, float* %40
%290 = fpext float %289 to double
%291 = load double, double* %29
%292 = load float, float* %41
%293 = fpext float %292 to double
%294 = load double, double* %30
%295 = fmul double %293, %294
%296 = fneg double %295
%297 = call double @llvm.fmuladd.f64(double %290, double %291, double %296)
%298 = fptrunc double %297 to float
%299 = load float*, float** %23
%300 = load i32, i32* %11
%301 = sext i32 %300 to i64
%302 = getelementptr inbounds float, float* %299, i64 %301
store float %298, float* %302
%303 = load float, float* %41
%304 = fpext float %303 to double
%305 = load double, double* %29
%306 = load float, float* %40
%307 = fpext float %306 to double
%308 = load double, double* %30
%309 = fmul double %307, %308
%310 = call double @llvm.fmuladd.f64(double %304, double %305, double %309)
%311 = fptrunc double %310 to float
%312 = load float*, float** %26
%313 = load i32, i32* %11
%314 = sext i32 %313 to i64
%315 = getelementptr inbounds float, float* %312, i64 %314
store float %311, float* %315
%316 = load i32, i32* %11
%317 = add nsw i32 %316, 1
store i32 %317, i32* %11
%318 = load i32, i32* %9
%319 = load float*, float** %34
%320 = sext i32 %318 to i64
%321 = getelementptr inbounds float, float* %319, i64 %320
store float* %321, float** %34
br label %237
322: ; preds = %237
br label %323
323: ; preds = %327, %322
%324 = load i32, i32* %11
%325 = load i32, i32* %22
%326 = icmp slt i32 %324, %325
br i1 %326, label %327, label %408
327: ; preds = %323
%328 = load float*, float** %24
%329 = load i32, i32* %11
%330 = sext i32 %329 to i64
%331 = getelementptr inbounds float, float* %328, i64 %330
%332 = load float, float* %331
store float %332, float* %38
%333 = load float*, float** %34
%334 = load i32, i32* %22
%335 = sext i32 %334 to i64
%336 = getelementptr inbounds float, float* %333, i64 %335
%337 = load float, float* %336
store float %337, float* %39
%338 = load float*, float** %23
%339 = load i32, i32* %11
%340 = sext i32 %339 to i64
%341 = getelementptr inbounds float, float* %338, i64 %340
%342 = load float, float* %341
store float %342, float* %40
%343 = load float*, float** %26
%344 = load i32, i32* %11
%345 = sext i32 %344 to i64
%346 = getelementptr inbounds float, float* %343, i64 %345
%347 = load float, float* %346
store float %347, float* %41
%348 = load float, float* %38
%349 = fpext float %348 to double
%350 = load double, double* %29
%351 = load float, float* %39
%352 = fpext float %351 to double
%353 = load double, double* %30
%354 = fmul double %352, %353
%355 = fneg double %354
%356 = call double @llvm.fmuladd.f64(double %349, double %350, double %355)
%357 = fptrunc double %356 to float
%358 = load float*, float** %24
%359 = load i32, i32* %11
%360 = sext i32 %359 to i64
%361 = getelementptr inbounds float, float* %358, i64 %360
store float %357, float* %361
%362 = load float, float* %39
%363 = fpext float %362 to double
%364 = load double, double* %29
%365 = load float, float* %38
%366 = fpext float %365 to double
%367 = load double, double* %30
%368 = fmul double %366, %367
%369 = call double @llvm.fmuladd.f64(double %363, double %364, double %368)
%370 = fptrunc double %369 to float
%371 = load float*, float** %34
%372 = load i32, i32* %22
%373 = sext i32 %372 to i64
%374 = getelementptr inbounds float, float* %371, i64 %373
store float %370, float* %374
%375 = load float, float* %40
%376 = fpext float %375 to double
%377 = load double, double* %29
%378 = load float, float* %41
%379 = fpext float %378 to double
%380 = load double, double* %30
%381 = fmul double %379, %380
%382 = fneg double %381
%383 = call double @llvm.fmuladd.f64(double %376, double %377, double %382)
%384 = fptrunc double %383 to float
%385 = load float*, float** %23
%386 = load i32, i32* %11
%387 = sext i32 %386 to i64
%388 = getelementptr inbounds float, float* %385, i64 %387
store float %384, float* %388
%389 = load float, float* %41
%390 = fpext float %389 to double
%391 = load double, double* %29
%392 = load float, float* %40
%393 = fpext float %392 to double
%394 = load double, double* %30
%395 = fmul double %393, %394
%396 = call double @llvm.fmuladd.f64(double %390, double %391, double %395)
%397 = fptrunc double %396 to float
%398 = load float*, float** %26
%399 = load i32, i32* %11
%400 = sext i32 %399 to i64
%401 = getelementptr inbounds float, float* %398, i64 %400
store float %397, float* %401
%402 = load i32, i32* %11
%403 = add nsw i32 %402, 1
store i32 %403, i32* %11
%404 = load i32, i32* %9
%405 = load float*, float** %34
%406 = sext i32 %404 to i64
%407 = getelementptr inbounds float, float* %405, i64 %406
store float* %407, float** %34
br label %323
408: ; preds = %323
br label %409
409: ; preds = %413, %408
%410 = load i32, i32* %11
%411 = load i32, i32* %9
%412 = icmp slt i32 %410, %411
br i1 %412, label %413, label %490
413: ; preds = %409
%414 = load float*, float** %24
%415 = load i32, i32* %11
%416 = sext i32 %415 to i64
%417 = getelementptr inbounds float, float* %414, i64 %416
%418 = load float, float* %417
store float %418, float* %38
%419 = load float*, float** %25
%420 = load i32, i32* %11
%421 = sext i32 %420 to i64
%422 = getelementptr inbounds float, float* %419, i64 %421
%423 = load float, float* %422
store float %423, float* %39
%424 = load float*, float** %23
%425 = load i32, i32* %11
%426 = sext i32 %425 to i64
%427 = getelementptr inbounds float, float* %424, i64 %426
%428 = load float, float* %427
store float %428, float* %40
%429 = load float*, float** %26
%430 = load i32, i32* %11
%431 = sext i32 %430 to i64
%432 = getelementptr inbounds float, float* %429, i64 %431
%433 = load float, float* %432
store float %433, float* %41
%434 = load float, float* %38
%435 = fpext float %434 to double
%436 = load double, double* %29
%437 = load float, float* %39
%438 = fpext float %437 to double
%439 = load double, double* %30
%440 = fmul double %438, %439
%441 = fneg double %440
%442 = call double @llvm.fmuladd.f64(double %435, double %436, double %441)
%443 = fptrunc double %442 to float
%444 = load float*, float** %24
%445 = load i32, i32* %11
%446 = sext i32 %445 to i64
%447 = getelementptr inbounds float, float* %444, i64 %446
store float %443, float* %447
%448 = load float, float* %39
%449 = fpext float %448 to double
%450 = load double, double* %29
%451 = load float, float* %38
%452 = fpext float %451 to double
%453 = load double, double* %30
%454 = fmul double %452, %453
%455 = call double @llvm.fmuladd.f64(double %449, double %450, double %454)
%456 = fptrunc double %455 to float
%457 = load float*, float** %25
%458 = load i32, i32* %11
%459 = sext i32 %458 to i64
%460 = getelementptr inbounds float, float* %457, i64 %459
store float %456, float* %460
%461 = load float, float* %40
%462 = fpext float %461 to double
%463 = load double, double* %29
%464 = load float, float* %41
%465 = fpext float %464 to double
%466 = load double, double* %30
%467 = fmul double %465, %466
%468 = fneg double %467
%469 = call double @llvm.fmuladd.f64(double %462, double %463, double %468)
%470 = fptrunc double %469 to float
%471 = load float*, float** %23
%472 = load i32, i32* %11
%473 = sext i32 %472 to i64
%474 = getelementptr inbounds float, float* %471, i64 %473
store float %470, float* %474
%475 = load float, float* %41
%476 = fpext float %475 to double
%477 = load double, double* %29
%478 = load float, float* %40
%479 = fpext float %478 to double
%480 = load double, double* %30
%481 = fmul double %479, %480
%482 = call double @llvm.fmuladd.f64(double %476, double %477, double %481)
%483 = fptrunc double %482 to float
%484 = load float*, float** %26
%485 = load i32, i32* %11
%486 = sext i32 %485 to i64
%487 = getelementptr inbounds float, float* %484, i64 %486
store float %483, float* %487
%488 = load i32, i32* %11
%489 = add nsw i32 %488, 1
store i32 %489, i32* %11
br label %409
490: ; preds = %409
%491 = load float, float* %36
%492 = fpext float %491 to double
%493 = load double, double* %31
%494 = load float, float* %37
%495 = fpext float %494 to double
%496 = load double, double* %32
%497 = fmul double %495, %496
%498 = call double @llvm.fmuladd.f64(double %492, double %493, double %497)
%499 = load double, double* %33
%500 = fsub double %498, %499
%501 = fptrunc double %500 to float
%502 = load float*, float** %24
%503 = load i32, i32* %21
%504 = sext i32 %503 to i64
%505 = getelementptr inbounds float, float* %502, i64 %504
store float %501, float* %505
%506 = load float, float* %36
%507 = fpext float %506 to double
%508 = load double, double* %32
%509 = load float, float* %37
%510 = fpext float %509 to double
%511 = load double, double* %31
%512 = fmul double %510, %511
%513 = call double @llvm.fmuladd.f64(double %507, double %508, double %512)
%514 = load double, double* %33
%515 = fadd double %513, %514
%516 = fptrunc double %515 to float
%517 = load float*, float** %25
%518 = load i32, i32* %22
%519 = sext i32 %518 to i64
%520 = getelementptr inbounds float, float* %517, i64 %519
store float %516, float* %520
store float 0.000000e+00, float* %46
%521 = load float, float* %46
%522 = load float*, float** %25
%523 = load i32, i32* %21
%524 = sext i32 %523 to i64
%525 = getelementptr inbounds float, float* %522, i64 %524
store float %521, float* %525
%526 = load float, float* %46
%527 = load float*, float** %24
%528 = load i32, i32* %22
%529 = sext i32 %528 to i64
%530 = getelementptr inbounds float, float* %527, i64 %529
store float %526, float* %530
br label %531
531: ; preds = %490, %172
%532 = load i32, i32* %22
%533 = add nsw i32 %532, 1
store i32 %533, i32* %22
%534 = load i32, i32* %9
%535 = load float*, float** %25
%536 = sext i32 %534 to i64
%537 = getelementptr inbounds float, float* %535, i64 %536
store float* %537, float** %25
%538 = load i32, i32* %9
%539 = load float*, float** %26
%540 = sext i32 %538 to i64
%541 = getelementptr inbounds float, float* %539, i64 %540
store float* %541, float** %26
br label %156
542: ; preds = %156
%543 = load i32, i32* %21
%544 = add nsw i32 %543, 1
store i32 %544, i32* %21
%545 = load i32, i32* %9
%546 = load float*, float** %24
%547 = sext i32 %545 to i64
%548 = getelementptr inbounds float, float* %546, i64 %547
store float* %548, float** %24
%549 = load i32, i32* %9
%550 = load float*, float** %23
%551 = sext i32 %549 to i64
%552 = getelementptr inbounds float, float* %550, i64 %551
store float* %552, float** %23
br label %134
553: ; preds = %134
%554 = load i32, i32* %14
%555 = icmp ne i32 %554, 0
br i1 %555, label %557, label %556
556: ; preds = %553
br label %558
557: ; preds = %553
br label %131
558: ; preds = %556
%559 = load i32, i32* %9
%560 = sitofp i32 %559 to double
%561 = load double, double* %17
%562 = fdiv double %561, %560
store double %562, double* %17
br label %122
563: ; preds = %122
store i32 0, i32* %11
store i32 0, i32* %13
br label %564
564: ; preds = %568, %563
%565 = load i32, i32* %11
%566 = load i32, i32* %9
%567 = icmp slt i32 %565, %566
br i1 %567, label %568, label %584
568: ; preds = %564
%569 = load float*, float** %6
%570 = load i32, i32* %13
%571 = sext i32 %570 to i64
%572 = getelementptr inbounds float, float* %569, i64 %571
%573 = load float, float* %572
%574 = load float*, float** %8
%575 = load i32, i32* %11
%576 = sext i32 %575 to i64
%577 = getelementptr inbounds float, float* %574, i64 %576
store float %573, float* %577
%578 = load i32, i32* %11
%579 = add nsw i32 %578, 1
store i32 %579, i32* %11
%580 = load i32, i32* %9
%581 = add nsw i32 %580, 1
%582 = load i32, i32* %13
%583 = add nsw i32 %582, %581
store i32 %583, i32* %13
br label %564
584: ; preds = %564
store i32 0, i32* %11
br label %585
585: ; preds = %695, %584
%586 = load i32, i32* %11
%587 = load i32, i32* %9
%588 = icmp slt i32 %586, %587
br i1 %588, label %589, label %698
589: ; preds = %585
%590 = load i32, i32* %11
store i32 %590, i32* %47
%591 = load float*, float** %8
%592 = load i32, i32* %11
%593 = sext i32 %592 to i64
%594 = getelementptr inbounds float, float* %591, i64 %593
%595 = load float, float* %594
%596 = fpext float %595 to double
%597 = call double @llvm.fabs.f64(double %596)
store double %597, double* %49
%598 = load double, double* %49
%599 = fptrunc double %598 to float
store float %599, float* %48
%600 = load i32, i32* %11
%601 = add nsw i32 %600, 1
store i32 %601, i32* %12
br label %602
602: ; preds = %631, %589
%603 = load i32, i32* %12
%604 = load i32, i32* %9
%605 = icmp slt i32 %603, %604
br i1 %605, label %606, label %634
606: ; preds = %602
%607 = load float*, float** %8
%608 = load i32, i32* %12
%609 = sext i32 %608 to i64
%610 = getelementptr inbounds float, float* %607, i64 %609
%611 = load float, float* %610
%612 = fpext float %611 to double
%613 = call double @llvm.fabs.f64(double %612)
store double %613, double* %51
%614 = load double, double* %51
%615 = fptrunc double %614 to float
store float %615, float* %50
%616 = load float, float* %48
%617 = load float, float* %50
%618 = fcmp olt float %616, %617
br i1 %618, label %619, label %621
619: ; preds = %606
%620 = load i32, i32* %12
store i32 %620, i32* %47
br label %623
621: ; preds = %606
%622 = load i32, i32* %47
store i32 %622, i32* %47
br label %623
623: ; preds = %621, %619
%624 = load float, float* %48
%625 = load float, float* %50
%626 = fcmp olt float %624, %625
br i1 %626, label %627, label %629
627: ; preds = %623
%628 = load float, float* %50
store float %628, float* %48
br label %631
629: ; preds = %623
%630 = load float, float* %48
store float %630, float* %48
br label %631
631: ; preds = %629, %627
%632 = load i32, i32* %12
%633 = add nsw i32 %632, 1
store i32 %633, i32* %12
br label %602
634: ; preds = %602
%635 = load i32, i32* %47
%636 = load i32, i32* %11
%637 = icmp ne i32 %635, %636
br i1 %637, label %638, label %695
638: ; preds = %634
%639 = load float*, float** %8
%640 = load i32, i32* %11
%641 = sext i32 %640 to i64
%642 = getelementptr inbounds float, float* %639, i64 %641
%643 = load float, float* %642
store float %643, float* %53
%644 = load float*, float** %8
%645 = load i32, i32* %47
%646 = sext i32 %645 to i64
%647 = getelementptr inbounds float, float* %644, i64 %646
%648 = load float, float* %647
%649 = load float*, float** %8
%650 = load i32, i32* %11
%651 = sext i32 %650 to i64
%652 = getelementptr inbounds float, float* %649, i64 %651
store float %648, float* %652
%653 = load float, float* %53
%654 = load float*, float** %8
%655 = load i32, i32* %47
%656 = sext i32 %655 to i64
%657 = getelementptr inbounds float, float* %654, i64 %656
store float %653, float* %657
store i32 0, i32* %12
%658 = load i32, i32* %11
%659 = load i32, i32* %9
%660 = mul nsw i32 %658, %659
store i32 %660, i32* %13
%661 = load i32, i32* %47
%662 = load i32, i32* %9
%663 = mul nsw i32 %661, %662
store i32 %663, i32* %52
br label %664
664: ; preds = %668, %638
%665 = load i32, i32* %12
%666 = load i32, i32* %9
%667 = icmp slt i32 %665, %666
br i1 %667, label %668, label %694
668: ; preds = %664
%669 = load float*, float** %7
%670 = load i32, i32* %13
%671 = sext i32 %670 to i64
%672 = getelementptr inbounds float, float* %669, i64 %671
%673 = load float, float* %672
store float %673, float* %53
%674 = load float*, float** %7
%675 = load i32, i32* %52
%676 = sext i32 %675 to i64
%677 = getelementptr inbounds float, float* %674, i64 %676
%678 = load float, float* %677
%679 = load float*, float** %7
%680 = load i32, i32* %13
%681 = sext i32 %680 to i64
%682 = getelementptr inbounds float, float* %679, i64 %681
store float %678, float* %682
%683 = load float, float* %53
%684 = load float*, float** %7
%685 = load i32, i32* %52
%686 = sext i32 %685 to i64
%687 = getelementptr inbounds float, float* %684, i64 %686
store float %683, float* %687
%688 = load i32, i32* %12
%689 = add nsw i32 %688, 1
store i32 %689, i32* %12
%690 = load i32, i32* %13
%691 = add nsw i32 %690, 1
store i32 %691, i32* %13
%692 = load i32, i32* %52
%693 = add nsw i32 %692, 1
store i32 %693, i32* %52
br label %664
694: ; preds = %664
br label %695
695: ; preds = %694, %634
%696 = load i32, i32* %11
%697 = add nsw i32 %696, 1
store i32 %697, i32* %11
br label %585
698: ; preds = %585
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 %689
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 ], [ %1, %183 ]
%191 = phi float* [ %479, %474 ], [ %0, %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* %191, 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* [ %202, %200 ], [ %464, %461 ]
%211 = phi float* [ %201, %200 ], [ %465, %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* %191, i64 %208
%217 = load float, float* %216
%218 = fpext float %217 to double
%219 = tail call double @llvm.fabs.f64(double %218)
%220 = fcmp olt double %219, %185
br i1 %220, label %461, label %221
221: ; preds = %206
%222 = load float, float* %203
%223 = getelementptr inbounds float, float* %210, i64 %208
%224 = load float, float* %223
%225 = fsub float %222, %224
%226 = fpext float %225 to double
%227 = fmul double %226, 5.000000e-01
%228 = fmul float %217, %217
%229 = fpext float %228 to double
%230 = tail call double @llvm.fmuladd.f64(double %227, double %227, double %229)
%231 = tail call double @sqrt(double %230)
%232 = fneg float %217
%233 = fpext float %232 to double
%234 = fdiv double %233, %231
%235 = fcmp olt double %227, 0.000000e+00
%236 = fneg double %234
%237 = select i1 %235, double %236, double %234
%238 = fneg double %237
%239 = tail call double @llvm.fmuladd.f64(double %238, double %237, double 1.000000e+00)
%240 = tail call double @sqrt(double %239)
%241 = fadd double %240, 1.000000e+00
%242 = fmul double %241, 2.000000e+00
%243 = tail call double @sqrt(double %242)
%244 = fdiv double %237, %243
%245 = fmul double %244, %244
%246 = fsub double 1.000000e+00, %245
%247 = tail call double @sqrt(double %246)
%248 = fmul double %247, %247
%249 = fmul double %218, 2.000000e+00
%250 = fmul double %249, %247
%251 = fmul double %250, %244
br i1 %204, label %254, label %252
252: ; preds = %221
%253 = fneg double %244
br label %261
254: ; preds = %261, %221
%255 = phi float* [ %0, %221 ], [ %289, %261 ]
%256 = phi i32 [ 0, %221 ], [ %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 %244
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* %190, i64 %262
%269 = load float, float* %268
%270 = getelementptr inbounds float, float* %211, 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 %247, double %274)
%276 = fptrunc double %275 to float
store float %276, float* %264
%277 = fmul double %244, %272
%278 = tail call double @llvm.fmuladd.f64(double %273, double %247, 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 %247, double %282)
%284 = fptrunc double %283 to float
store float %284, float* %268
%285 = fmul double %244, %280
%286 = tail call double @llvm.fmuladd.f64(double %281, double %247, 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 %244
%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* %191, 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* %210, i64 %298
%312 = getelementptr float, float* %214, i64 %309
%313 = getelementptr float, float* %190, i64 %298
%314 = getelementptr float, float* %196, i64 %309
%315 = getelementptr float, float* %211, 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 %247, i64 0
%346 = shufflevector <4 x double> %345, <4 x double> poison, <4 x i32> zeroinitializer
%347 = insertelement <4 x double> poison, double %244, 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* %191, i64 %351
%353 = bitcast float* %352 to <4 x float>*
%354 = load <4 x float>, <4 x float>* %353
%355 = getelementptr inbounds float, float* %210, i64 %351
%356 = bitcast float* %355 to <4 x float>*
%357 = load <4 x float>, <4 x float>* %356
%358 = getelementptr inbounds float, float* %190, i64 %351
%359 = bitcast float* %358 to <4 x float>*
%360 = load <4 x float>, <4 x float>* %359
%361 = getelementptr inbounds float, float* %211, 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* %191, 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* %190, i64 %391
%398 = load float, float* %397
%399 = getelementptr inbounds float, float* %211, 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 %247, double %403)
%405 = fptrunc double %404 to float
store float %405, float* %393
%406 = fmul double %244, %401
%407 = tail call double @llvm.fmuladd.f64(double %402, double %247, 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 %247, double %411)
%413 = fptrunc double %412 to float
store float %413, float* %397
%414 = fmul double %244, %409
%415 = tail call double @llvm.fmuladd.f64(double %410, double %247, 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* %191, i64 %421
%423 = load float, float* %422
%424 = getelementptr inbounds float, float* %210, i64 %421
%425 = load float, float* %424
%426 = getelementptr inbounds float, float* %190, i64 %421
%427 = load float, float* %426
%428 = getelementptr inbounds float, float* %211, 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 %247, double %432)
%434 = fptrunc double %433 to float
store float %434, float* %422
%435 = fmul double %244, %430
%436 = tail call double @llvm.fmuladd.f64(double %431, double %247, 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 %247, double %440)
%442 = fptrunc double %441 to float
store float %442, float* %426
%443 = fmul double %244, %438
%444 = tail call double @llvm.fmuladd.f64(double %439, double %247, 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 %222 to double
%451 = fpext float %224 to double
%452 = fmul double %245, %451
%453 = tail call double @llvm.fmuladd.f64(double %450, double %248, double %452)
%454 = fsub double %453, %251
%455 = fptrunc double %454 to float
store float %455, float* %203
%456 = fmul double %248, %451
%457 = tail call double @llvm.fmuladd.f64(double %450, double %245, double %456)
%458 = fadd double %251, %457
%459 = fptrunc double %458 to float
store float %459, float* %223
%460 = getelementptr inbounds float, float* %210, 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 [ %209, %206 ], [ 1, %449 ]
%463 = add nuw nsw i64 %208, 1
%464 = getelementptr inbounds float, float* %210, i64 %87
%465 = getelementptr inbounds float, float* %211, 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* %191, i64 %87
%471 = getelementptr inbounds float, float* %190, 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* [ %471, %468 ], [ %1, %480 ]
%479 = phi float* [ %470, %468 ], [ %0, %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 %689
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, %685
%535 = phi i64 [ 0, %487 ], [ %544, %685 ]
%536 = phi i32 [ 0, %487 ], [ %687, %685 ]
%537 = phi i64 [ 1, %487 ], [ %686, %685 ]
%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 = add nuw nsw i64 %535, 1
%545 = icmp ult i64 %544, %488
%546 = trunc i64 %535 to i32
br i1 %545, label %547, label %562
547: ; preds = %534
%548 = tail call float @llvm.fabs.f32(float %543)
br label %549
549: ; preds = %547, %549
%550 = phi i64 [ %537, %547 ], [ %560, %549 ]
%551 = phi float [ %548, %547 ], [ %559, %549 ]
%552 = phi i32 [ %546, %547 ], [ %558, %549 ]
%553 = getelementptr inbounds float, float* %2, i64 %550
%554 = load float, float* %553
%555 = tail call float @llvm.fabs.f32(float %554)
%556 = fcmp olt float %551, %555
%557 = trunc i64 %550 to i32
%558 = select i1 %556, i32 %557, i32 %552
%559 = select i1 %556, float %555, float %551
%560 = add nuw nsw i64 %550, 1
%561 = icmp eq i64 %560, %489
br i1 %561, label %562, label %549
562: ; preds = %549, %534
%563 = phi i32 [ %546, %534 ], [ %558, %549 ]
%564 = zext i32 %563 to i64
%565 = icmp eq i64 %535, %564
br i1 %565, label %685, label %566
566: ; preds = %562
%567 = sext i32 %563 to i64
%568 = getelementptr inbounds float, float* %2, i64 %567
%569 = load float, float* %568
store float %569, float* %542
store float %543, float* %568
%570 = mul i32 %563, %3
%571 = sext i32 %570 to i64
br i1 %501, label %646, label %572
572: ; preds = %566
%573 = getelementptr float, float* %1, i64 %571
%574 = getelementptr float, float* %494, i64 %571
%575 = icmp ult float* %539, %574
%576 = icmp ult float* %573, %540
%577 = and i1 %575, %576
br i1 %577, label %646, label %578
578: ; preds = %572
%579 = add nsw i64 %502, %541
%580 = add nsw i64 %502, %571
br i1 %505, label %624, label %581
581: ; preds = %578, %581
%582 = phi i64 [ %621, %581 ], [ 0, %578 ]
%583 = phi i64 [ %622, %581 ], [ 0, %578 ]
%584 = add i64 %582, %541
%585 = add i64 %582, %571
%586 = getelementptr inbounds float, float* %1, i64 %584
%587 = bitcast float* %586 to <4 x float>*
%588 = load <4 x float>, <4 x float>* %587
%589 = getelementptr inbounds float, float* %586, i64 4
%590 = bitcast float* %589 to <4 x float>*
%591 = load <4 x float>, <4 x float>* %590
%592 = getelementptr inbounds float, float* %1, i64 %585
%593 = bitcast float* %592 to <4 x float>*
%594 = load <4 x float>, <4 x float>* %593
%595 = getelementptr inbounds float, float* %592, i64 4
%596 = bitcast float* %595 to <4 x float>*
%597 = load <4 x float>, <4 x float>* %596
%598 = bitcast float* %586 to <4 x float>*
store <4 x float> %594, <4 x float>* %598
%599 = bitcast float* %589 to <4 x float>*
store <4 x float> %597, <4 x float>* %599
%600 = bitcast float* %592 to <4 x float>*
store <4 x float> %588, <4 x float>* %600
%601 = bitcast float* %595 to <4 x float>*
store <4 x float> %591, <4 x float>* %601
%602 = or i64 %582, 8
%603 = add i64 %602, %541
%604 = add i64 %602, %571
%605 = getelementptr inbounds float, float* %1, i64 %603
%606 = bitcast float* %605 to <4 x float>*
%607 = load <4 x float>, <4 x float>* %606
%608 = getelementptr inbounds float, float* %605, i64 4
%609 = bitcast float* %608 to <4 x float>*
%610 = load <4 x float>, <4 x float>* %609
%611 = getelementptr inbounds float, float* %1, i64 %604
%612 = bitcast float* %611 to <4 x float>*
%613 = load <4 x float>, <4 x float>* %612
%614 = getelementptr inbounds float, float* %611, i64 4
%615 = bitcast float* %614 to <4 x float>*
%616 = load <4 x float>, <4 x float>* %615
%617 = bitcast float* %605 to <4 x float>*
store <4 x float> %613, <4 x float>* %617
%618 = bitcast float* %608 to <4 x float>*
store <4 x float> %616, <4 x float>* %618
%619 = bitcast float* %611 to <4 x float>*
store <4 x float> %607, <4 x float>* %619
%620 = bitcast float* %614 to <4 x float>*
store <4 x float> %610, <4 x float>* %620
%621 = add nuw i64 %582, 16
%622 = add i64 %583, 2
%623 = icmp eq i64 %622, %506
br i1 %623, label %624, label %581
624: ; preds = %581, %578
%625 = phi i64 [ 0, %578 ], [ %621, %581 ]
br i1 %507, label %645, label %626
626: ; preds = %624
%627 = add i64 %625, %541
%628 = add i64 %625, %571
%629 = getelementptr inbounds float, float* %1, i64 %627
%630 = bitcast float* %629 to <4 x float>*
%631 = load <4 x float>, <4 x float>* %630
%632 = getelementptr inbounds float, float* %629, i64 4
%633 = bitcast float* %632 to <4 x float>*
%634 = load <4 x float>, <4 x float>* %633
%635 = getelementptr inbounds float, float* %1, i64 %628
%636 = bitcast float* %635 to <4 x float>*
%637 = load <4 x float>, <4 x float>* %636
%638 = getelementptr inbounds float, float* %635, i64 4
%639 = bitcast float* %638 to <4 x float>*
%640 = load <4 x float>, <4 x float>* %639
%641 = bitcast float* %629 to <4 x float>*
store <4 x float> %637, <4 x float>* %641
%642 = bitcast float* %632 to <4 x float>*
store <4 x float> %640, <4 x float>* %642
%643 = bitcast float* %635 to <4 x float>*
store <4 x float> %631, <4 x float>* %643
%644 = bitcast float* %638 to <4 x float>*
store <4 x float> %634, <4 x float>* %644
br label %645
645: ; preds = %624, %626
br i1 %508, label %685, label %646
646: ; preds = %572, %566, %645
%647 = phi i64 [ %541, %572 ], [ %541, %566 ], [ %579, %645 ]
%648 = phi i64 [ %571, %572 ], [ %571, %566 ], [ %580, %645 ]
%649 = phi i32 [ 0, %572 ], [ 0, %566 ], [ %503, %645 ]
%650 = sub i32 %3, %649
%651 = xor i32 %649, -1
%652 = and i32 %650, 1
%653 = icmp eq i32 %652, 0
br i1 %653, label %662, label %654
654: ; preds = %646
%655 = getelementptr inbounds float, float* %1, i64 %647
%656 = load float, float* %655
%657 = getelementptr inbounds float, float* %1, i64 %648
%658 = load float, float* %657
store float %658, float* %655
store float %656, float* %657
%659 = add nuw nsw i32 %649, 1
%660 = add nsw i64 %647, 1
%661 = add nsw i64 %648, 1
br label %662
662: ; preds = %654, %646
%663 = phi i64 [ %647, %646 ], [ %660, %654 ]
%664 = phi i64 [ %648, %646 ], [ %661, %654 ]
%665 = phi i32 [ %649, %646 ], [ %659, %654 ]
%666 = icmp eq i32 %651, %509
br i1 %666, label %685, label %667
667: ; preds = %662, %667
%668 = phi i64 [ %682, %667 ], [ %663, %662 ]
%669 = phi i64 [ %683, %667 ], [ %664, %662 ]
%670 = phi i32 [ %681, %667 ], [ %665, %662 ]
%671 = getelementptr inbounds float, float* %1, i64 %668
%672 = load float, float* %671
%673 = getelementptr inbounds float, float* %1, i64 %669
%674 = load float, float* %673
store float %674, float* %671
store float %672, float* %673
%675 = add nsw i64 %668, 1
%676 = add nsw i64 %669, 1
%677 = getelementptr inbounds float, float* %1, i64 %675
%678 = load float, float* %677
%679 = getelementptr inbounds float, float* %1, i64 %676
%680 = load float, float* %679
store float %680, float* %677
store float %678, float* %679
%681 = add nuw nsw i32 %670, 2
%682 = add nsw i64 %668, 2
%683 = add nsw i64 %669, 2
%684 = icmp eq i32 %681, %3
br i1 %684, label %685, label %667
685: ; preds = %662, %667, %645, %562
%686 = add nuw nsw i64 %537, 1
%687 = add i32 %536, %3
%688 = icmp eq i64 %544, %489
br i1 %688, label %689, label %534
689: ; preds = %685, %91, %486
ret i32 0
}