int moistiv_epipolar(float *m1, float *m2, int *k, float *z, float F1[4][4],
                     float F2[4][4]) {
  int i, j, i2, i3, imin1, imin2;
  float wmin1, wmin2;
  float **c = matrix(1, 9, 1, 9);
  float *w = vector(1, 9);
  float **v = matrix(1, 9, 1, 9);
  float a[4];
  for (i = 0; i < 7; i++) {
    c[i + 1][1] = m1[k[i] * 2] * m2[k[i] * 2];
    c[i + 1][2] = m1[k[i] * 2 + 1] * m2[k[i] * 2];
    c[i + 1][3] = m2[k[i] * 2];
    c[i + 1][4] = m1[k[i] * 2] * m2[k[i] * 2 + 1];
    c[i + 1][5] = m1[k[i] * 2 + 1] * m2[k[i] * 2 + 1];
    c[i + 1][6] = m2[k[i] * 2 + 1];
    c[i + 1][7] = m1[k[i] * 2];
    c[i + 1][8] = m1[k[i] * 2 + 1];
    c[i + 1][9] = 1.;
  }
  for (i = 1; i <= 9; i++)
    c[8][i] = c[9][i] = 0.;
  svdcmp(c, 9, 9, w, v);
  if (w[1] < w[2]) {
    imin1 = 1;
    imin2 = 2;
  } else {
    imin2 = 1;
    imin1 = 2;
  }
  wmin1 = w[imin1];
  wmin2 = w[imin2];
  for (i = 3; i <= 9; i++) {
    if (w[i] < wmin1) {
      imin2 = imin1;
      wmin2 = wmin1;
      wmin1 = w[i];
      imin1 = i;
    } else if (w[i] < wmin2) {
      wmin2 = w[i];
      imin2 = i;
    }
  }
  for (i = 1; i <= 3; i++)
    for (j = 1; j <= 3; j++) {
      F1[i][j] = v[(i - 1) * 3 + j][imin1];
      F2[i][j] = v[(i - 1) * 3 + j][imin2] - F1[i][j];
    }
  a[0] = a[1] = a[2] = a[3] = 0.;
  for (i = 1; i <= 3; i++) {
    i2 = i % 3 + 1;
    i3 = i2 % 3 + 1;
    a[0] += F1[i][1] * F1[i2][2] * F1[i3][3];
    a[1] += F2[i][1] * F1[i2][2] * F1[i3][3] +
            F1[i][1] * F2[i2][2] * F1[i3][3] + F1[i][1] * F1[i2][2] * F2[i3][3];
    a[2] += F1[i][1] * F2[i2][2] * F2[i3][3] +
            F2[i][1] * F1[i2][2] * F2[i3][3] + F2[i][1] * F2[i2][2] * F1[i3][3];
    a[3] += F2[i][1] * F2[i2][2] * F2[i3][3];
  }
  for (i = 1; i <= 3; i++) {
    i2 = (i + 1) % 3 + 1;
    i3 = (i2 + 1) % 3 + 1;
    a[0] -= F1[i][1] * F1[i2][2] * F1[i3][3];
    a[1] -= F2[i][1] * F1[i2][2] * F1[i3][3] +
            F1[i][1] * F2[i2][2] * F1[i3][3] + F1[i][1] * F1[i2][2] * F2[i3][3];
    a[2] -= F1[i][1] * F2[i2][2] * F2[i3][3] +
            F2[i][1] * F1[i2][2] * F2[i3][3] + F2[i][1] * F2[i2][2] * F1[i3][3];
    a[3] -= F2[i][1] * F2[i2][2] * F2[i3][3];
  }
  free_matrix(c, 1, 9, 1, 9);
  free_matrix(v, 1, 9, 1, 9);
  free_vector(w, 1, 9);
  return (FindCubicRoots(a, z));
}


x86 assembly (clang, -O0):
<moistiv_epipolar>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    $0x1,%edx
mov    $0x9,%ecx
mov    %edx,%edi
mov    %ecx,%esi
mov    $0x0,%al
call   1060 <matrix@plt>
cltq
mov    %rax,-0x58(%rbp)
mov    $0x1,%edi
mov    $0x9,%esi
mov    $0x0,%al
call   1070 <vector@plt>
cltq
mov    %rax,-0x60(%rbp)
mov    $0x1,%edx
mov    $0x9,%ecx
mov    %edx,%edi
mov    %ecx,%esi
mov    $0x0,%al
call   1060 <matrix@plt>
cltq
mov    %rax,-0x68(%rbp)
movl   $0x0,-0x34(%rbp)
cmpl   $0x7,-0x34(%rbp)
jge    1407 <moistiv_epipolar+0x2a7>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%rcx
movslq -0x34(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
movslq -0x34(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x58(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movss  %xmm0,0x4(%rax)
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%rcx
movslq -0x34(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
movslq -0x34(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x58(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movss  %xmm0,0x8(%rax)
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
movslq -0x34(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x58(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movss  %xmm0,0xc(%rax)
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%rcx
movslq -0x34(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
movslq -0x34(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x58(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movss  %xmm0,0x10(%rax)
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%rcx
movslq -0x34(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
movslq -0x34(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x58(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movss  %xmm0,0x14(%rax)
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
movslq -0x34(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x58(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movss  %xmm0,0x18(%rax)
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%rcx
movslq -0x34(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x58(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movss  %xmm0,0x1c(%rax)
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%rcx
movslq -0x34(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x58(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movss  %xmm0,0x20(%rax)
mov    -0x58(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movss  0xc0c(%rip),%xmm0
movss  %xmm0,0x24(%rax)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11d7 <moistiv_epipolar+0x77>
movl   $0x1,-0x34(%rbp)
cmpl   $0x9,-0x34(%rbp)
jg     144e <moistiv_epipolar+0x2ee>
mov    -0x58(%rbp),%rax
mov    0x48(%rax),%rax
movslq -0x34(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x58(%rbp),%rax
mov    0x40(%rax),%rax
movslq -0x34(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    140e <moistiv_epipolar+0x2ae>
mov    -0x58(%rbp),%rdi
mov    -0x60(%rbp),%rcx
mov    -0x68(%rbp),%r8
mov    $0x9,%edx
mov    %edx,%esi
mov    $0x0,%al
call   1050 <svdcmp@plt>
mov    -0x60(%rbp),%rax
movss  0x4(%rax),%xmm1
mov    -0x60(%rbp),%rax
movss  0x8(%rax),%xmm0
ucomiss %xmm1,%xmm0
jbe    1496 <moistiv_epipolar+0x336>
movl   $0x1,-0x44(%rbp)
movl   $0x2,-0x48(%rbp)
jmp    14a4 <moistiv_epipolar+0x344>
movl   $0x1,-0x48(%rbp)
movl   $0x2,-0x44(%rbp)
mov    -0x60(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x60(%rbp),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x50(%rbp)
movl   $0x3,-0x34(%rbp)
cmpl   $0x9,-0x34(%rbp)
jg     156c <moistiv_epipolar+0x40c>
mov    -0x60(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x4c(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1521 <moistiv_epipolar+0x3c1>
mov    -0x44(%rbp),%eax
mov    %eax,-0x48(%rbp)
movss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x60(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x44(%rbp)
jmp    1559 <moistiv_epipolar+0x3f9>
mov    -0x60(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x50(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1554 <moistiv_epipolar+0x3f4>
mov    -0x60(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x48(%rbp)
jmp    1559 <moistiv_epipolar+0x3f9>
jmp    155e <moistiv_epipolar+0x3fe>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    14cf <moistiv_epipolar+0x36f>
movl   $0x1,-0x34(%rbp)
cmpl   $0x3,-0x34(%rbp)
jg     1637 <moistiv_epipolar+0x4d7>
movl   $0x1,-0x38(%rbp)
cmpl   $0x3,-0x38(%rbp)
jg     1624 <moistiv_epipolar+0x4c4>
mov    -0x68(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
imul   $0x3,%ecx,%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
imul   $0x3,%ecx,%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1584 <moistiv_epipolar+0x424>
jmp    1629 <moistiv_epipolar+0x4c9>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1573 <moistiv_epipolar+0x413>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x74(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x78(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x7c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x80(%rbp)
movl   $0x1,-0x34(%rbp)
cmpl   $0x3,-0x34(%rbp)
jg     18d0 <moistiv_epipolar+0x770>
mov    -0x34(%rbp),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
add    $0x1,%edx
mov    %edx,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
add    $0x1,%edx
mov    %edx,-0x40(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movss  0x4(%rax),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
mulss  0x8(%rax),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x40(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movss  0xc(%rax),%xmm2
movss  -0x80(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x80(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movss  0x4(%rax),%xmm1
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
mulss  0x8(%rax),%xmm1
mov    -0x28(%rbp),%rax
movslq -0x40(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movss  0xc(%rax),%xmm2
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movss  0x4(%rax),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
mulss  0x8(%rax),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x40(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
mulss  0xc(%rax),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movss  0x4(%rax),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
mulss  0x8(%rax),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x40(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movss  0xc(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
addss  -0x7c(%rbp),%xmm0
movss  %xmm0,-0x7c(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movss  0x4(%rax),%xmm1
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
mulss  0x8(%rax),%xmm1
mov    -0x30(%rbp),%rax
movslq -0x40(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movss  0xc(%rax),%xmm2
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movss  0x4(%rax),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
mulss  0x8(%rax),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x40(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
mulss  0xc(%rax),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movss  0x4(%rax),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
mulss  0x8(%rax),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x40(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movss  0xc(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
addss  -0x78(%rbp),%xmm0
movss  %xmm0,-0x78(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movss  0x4(%rax),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
mulss  0x8(%rax),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x40(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movss  0xc(%rax),%xmm2
movss  -0x74(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x74(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    165e <moistiv_epipolar+0x4fe>
movl   $0x1,-0x34(%rbp)
cmpl   $0x3,-0x34(%rbp)
jg     1b71 <moistiv_epipolar+0xa11>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
add    $0x1,%edx
mov    %edx,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
add    $0x1,%edx
mov    %edx,-0x40(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movss  0x4(%rax),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
mulss  0x8(%rax),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x40(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movss  0xc(%rax),%xmm2
movss  -0x80(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x80(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movss  0x4(%rax),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
mulss  0x8(%rax),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x40(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movss  0xc(%rax),%xmm2
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movss  0x4(%rax),%xmm1
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
mulss  0x8(%rax),%xmm1
mov    -0x28(%rbp),%rax
movslq -0x40(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
mulss  0xc(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movss  0x4(%rax),%xmm1
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
mulss  0x8(%rax),%xmm1
mov    -0x30(%rbp),%rax
movslq -0x40(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movss  0xc(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x7c(%rbp),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,-0x7c(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movss  0x4(%rax),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
mulss  0x8(%rax),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x40(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movss  0xc(%rax),%xmm2
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movss  0x4(%rax),%xmm1
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
mulss  0x8(%rax),%xmm1
mov    -0x30(%rbp),%rax
movslq -0x40(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
mulss  0xc(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movss  0x4(%rax),%xmm1
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
mulss  0x8(%rax),%xmm1
mov    -0x28(%rbp),%rax
movslq -0x40(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movss  0xc(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x78(%rbp),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,-0x78(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movss  0x4(%rax),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
mulss  0x8(%rax),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x40(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movss  0xc(%rax),%xmm2
movss  -0x74(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x74(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    18d7 <moistiv_epipolar+0x777>
mov    -0x58(%rbp),%rdi
mov    $0x1,%ecx
mov    $0x9,%r8d
mov    %ecx,%esi
mov    %r8d,%edx
mov    $0x0,%al
call   1030 <free_matrix@plt>
mov    -0x68(%rbp),%rdi
mov    $0x1,%ecx
mov    $0x9,%r8d
mov    %ecx,%esi
mov    %r8d,%edx
mov    $0x0,%al
call   1030 <free_matrix@plt>
mov    -0x60(%rbp),%rdi
mov    $0x1,%esi
mov    $0x9,%edx
mov    $0x0,%al
call   1040 <free_vector@plt>
lea    -0x80(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    $0x0,%al
call   1080 <FindCubicRoots@plt>
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<moistiv_epipolar>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %r9,%r13
mov    %r8,%rbp
mov    %rcx,0x50(%rsp)
mov    %rdx,%r14
mov    %rsi,%r12
mov    %rdi,%r15
mov    $0x1,%edi
mov    $0x9,%esi
mov    $0x1,%edx
mov    $0x9,%ecx
xor    %eax,%eax
call   1060 <matrix@plt>
movslq %eax,%rbx
mov    $0x1,%edi
mov    $0x9,%esi
xor    %eax,%eax
call   1070 <vector@plt>
cltq
mov    %rax,0x48(%rsp)
mov    $0x1,%edi
mov    $0x9,%esi
mov    $0x1,%edx
mov    $0x9,%ecx
xor    %eax,%eax
call   1060 <matrix@plt>
movslq %eax,%r8
mov    $0x1,%eax
nopl   0x0(%rax,%rax,1)
movslq -0x4(%r14,%rax,4),%rcx
movss  (%r15,%rcx,8),%xmm0
mulss  (%r12,%rcx,8),%xmm0
lea    (%rcx,%rcx,1),%rdx
mov    (%rbx,%rax,8),%rsi
or     $0x1,%edx
movss  %xmm0,0x4(%rsi)
movslq %edx,%rdx
movss  (%r15,%rdx,4),%xmm0
mulss  (%r12,%rcx,8),%xmm0
movss  %xmm0,0x8(%rsi)
movss  (%r12,%rcx,8),%xmm0
movss  %xmm0,0xc(%rsi)
movss  (%r15,%rcx,8),%xmm0
mulss  (%r12,%rdx,4),%xmm0
movss  %xmm0,0x10(%rsi)
movss  (%r15,%rdx,4),%xmm0
mulss  (%r12,%rdx,4),%xmm0
movss  %xmm0,0x14(%rsi)
movss  (%r12,%rdx,4),%xmm0
movss  %xmm0,0x18(%rsi)
movss  (%r15,%rcx,8),%xmm0
movss  %xmm0,0x1c(%rsi)
movss  (%r15,%rdx,4),%xmm0
movss  %xmm0,0x20(%rsi)
movl   $0x3f800000,0x24(%rsi)
add    $0x1,%rax
cmp    $0x8,%rax
jne    11e0 <moistiv_epipolar+0x80>
mov    0x40(%rbx),%rax
mov    0x48(%rbx),%rcx
movl   $0x0,0x4(%rcx)
movl   $0x0,0x4(%rax)
movl   $0x0,0x8(%rcx)
movl   $0x0,0x8(%rax)
movl   $0x0,0xc(%rcx)
movl   $0x0,0xc(%rax)
movl   $0x0,0x10(%rcx)
movl   $0x0,0x10(%rax)
movl   $0x0,0x14(%rcx)
movl   $0x0,0x14(%rax)
movl   $0x0,0x18(%rcx)
movl   $0x0,0x18(%rax)
movl   $0x0,0x1c(%rcx)
movl   $0x0,0x1c(%rax)
movl   $0x0,0x20(%rcx)
movl   $0x0,0x20(%rax)
movl   $0x0,0x24(%rcx)
movl   $0x0,0x24(%rax)
mov    %rbx,%rdi
mov    $0x9,%esi
mov    $0x9,%edx
mov    0x48(%rsp),%r14
mov    %r14,%rcx
mov    %r8,%r15
xor    %eax,%eax
call   1050 <svdcmp@plt>
movss  0x8(%r14),%xmm1
movss  0xc(%r14),%xmm0
xor    %eax,%eax
ucomiss 0x4(%r14),%xmm1
seta   %al
mov    $0x2,%edx
sub    %eax,%edx
movss  (%r14,%rdx,4),%xmm1
mov    $0x3,%ecx
ucomiss %xmm0,%xmm1
jbe    1354 <moistiv_epipolar+0x1f4>
mov    %edx,%eax
movaps %xmm0,%xmm2
movaps %xmm1,%xmm0
jmp    1376 <moistiv_epipolar+0x216>
add    $0x1,%eax
movss  (%r14,%rax,4),%xmm3
ucomiss %xmm0,%xmm3
jbe    136e <moistiv_epipolar+0x20e>
mov    $0x3,%eax
mov    %edx,%ecx
movaps %xmm1,%xmm2
jmp    1376 <moistiv_epipolar+0x216>
mov    %edx,%ecx
movaps %xmm1,%xmm2
movaps %xmm3,%xmm0
movss  0x10(%r14),%xmm1
mov    $0x4,%edx
ucomiss %xmm1,%xmm2
jbe    1390 <moistiv_epipolar+0x230>
mov    %ecx,%eax
movaps %xmm1,%xmm3
movaps %xmm2,%xmm1
jmp    13a9 <moistiv_epipolar+0x249>
ucomiss %xmm1,%xmm0
jbe    13a1 <moistiv_epipolar+0x241>
mov    $0x4,%eax
mov    %ecx,%edx
movaps %xmm2,%xmm3
jmp    13a9 <moistiv_epipolar+0x249>
mov    %ecx,%edx
movaps %xmm2,%xmm3
movaps %xmm0,%xmm1
movss  0x14(%r14),%xmm0
mov    $0x5,%ecx
ucomiss %xmm0,%xmm3
jbe    13c3 <moistiv_epipolar+0x263>
mov    %edx,%eax
movaps %xmm0,%xmm2
movaps %xmm3,%xmm0
jmp    13dc <moistiv_epipolar+0x27c>
ucomiss %xmm0,%xmm1
jbe    13d4 <moistiv_epipolar+0x274>
mov    $0x5,%eax
mov    %edx,%ecx
movaps %xmm3,%xmm2
jmp    13dc <moistiv_epipolar+0x27c>
mov    %edx,%ecx
movaps %xmm3,%xmm2
movaps %xmm1,%xmm0
movss  0x18(%r14),%xmm1
mov    $0x6,%edx
ucomiss %xmm1,%xmm2
jbe    13f6 <moistiv_epipolar+0x296>
mov    %ecx,%eax
movaps %xmm1,%xmm3
movaps %xmm2,%xmm1
jmp    140f <moistiv_epipolar+0x2af>
ucomiss %xmm1,%xmm0
jbe    1407 <moistiv_epipolar+0x2a7>
mov    $0x6,%eax
mov    %ecx,%edx
movaps %xmm2,%xmm3
jmp    140f <moistiv_epipolar+0x2af>
mov    %ecx,%edx
movaps %xmm2,%xmm3
movaps %xmm0,%xmm1
movss  0x1c(%r14),%xmm0
mov    $0x7,%ecx
ucomiss %xmm0,%xmm3
jbe    1429 <moistiv_epipolar+0x2c9>
mov    %edx,%eax
movaps %xmm0,%xmm2
movaps %xmm3,%xmm0
jmp    1442 <moistiv_epipolar+0x2e2>
ucomiss %xmm0,%xmm1
jbe    143a <moistiv_epipolar+0x2da>
mov    $0x7,%eax
mov    %edx,%ecx
movaps %xmm3,%xmm2
jmp    1442 <moistiv_epipolar+0x2e2>
mov    %edx,%ecx
movaps %xmm3,%xmm2
movaps %xmm1,%xmm0
movss  0x20(%r14),%xmm1
mov    $0x8,%edx
ucomiss %xmm1,%xmm2
jbe    145c <moistiv_epipolar+0x2fc>
mov    %ecx,%eax
movaps %xmm1,%xmm3
movaps %xmm2,%xmm1
jmp    1475 <moistiv_epipolar+0x315>
ucomiss %xmm1,%xmm0
jbe    146d <moistiv_epipolar+0x30d>
mov    $0x8,%eax
mov    %ecx,%edx
movaps %xmm2,%xmm3
jmp    1475 <moistiv_epipolar+0x315>
mov    %ecx,%edx
movaps %xmm2,%xmm3
movaps %xmm0,%xmm1
movss  0x24(%r14),%xmm0
mov    $0x9,%ecx
ucomiss %xmm0,%xmm3
jbe    1489 <moistiv_epipolar+0x329>
mov    %edx,%eax
jmp    1495 <moistiv_epipolar+0x335>
ucomiss %xmm0,%xmm1
jbe    1493 <moistiv_epipolar+0x333>
mov    $0x9,%eax
mov    %edx,%ecx
mov    %ecx,%ecx
mov    %eax,%eax
mov    0x8(%r15),%rdx
movss  (%rdx,%rcx,4),%xmm0
movss  %xmm0,0x14(%rbp)
movss  (%rdx,%rax,4),%xmm1
subss  %xmm0,%xmm1
movss  %xmm1,0x14(%r13)
mov    0x10(%r15),%rdx
movss  (%rdx,%rcx,4),%xmm0
movss  %xmm0,0x18(%rbp)
movss  (%rdx,%rax,4),%xmm1
subss  %xmm0,%xmm1
movss  %xmm1,0x18(%r13)
mov    0x18(%r15),%rdx
movss  (%rdx,%rcx,4),%xmm0
movss  %xmm0,0x1c(%rbp)
movss  (%rdx,%rax,4),%xmm1
subss  %xmm0,%xmm1
movss  %xmm1,0x1c(%r13)
mov    0x20(%r15),%rdx
movss  (%rdx,%rcx,4),%xmm0
movss  %xmm0,0x24(%rbp)
movss  (%rdx,%rax,4),%xmm1
subss  %xmm0,%xmm1
movss  %xmm1,0x24(%r13)
mov    0x28(%r15),%rdx
movss  (%rdx,%rcx,4),%xmm0
movss  %xmm0,0x28(%rbp)
movss  (%rdx,%rax,4),%xmm1
subss  %xmm0,%xmm1
movss  %xmm1,0x28(%r13)
mov    0x30(%r15),%rdx
movss  (%rdx,%rcx,4),%xmm0
movss  %xmm0,0x2c(%rbp)
movss  (%rdx,%rax,4),%xmm1
subss  %xmm0,%xmm1
movss  %xmm1,0x2c(%r13)
mov    0x38(%r15),%rdx
movss  (%rdx,%rcx,4),%xmm0
movss  %xmm0,0x34(%rbp)
movss  (%rdx,%rax,4),%xmm1
subss  %xmm0,%xmm1
movss  %xmm1,0x34(%r13)
mov    0x40(%r15),%rdx
movss  (%rdx,%rcx,4),%xmm0
movss  %xmm0,0x38(%rbp)
movss  (%rdx,%rax,4),%xmm1
subss  %xmm0,%xmm1
movss  %xmm1,0x38(%r13)
mov    0x48(%r15),%rdx
movss  (%rdx,%rcx,4),%xmm0
movss  %xmm0,0x3c(%rbp)
movss  (%rdx,%rax,4),%xmm2
subss  %xmm0,%xmm2
movss  %xmm2,0x3c(%r13)
movss  0x28(%rbp),%xmm1
movss  %xmm1,0x2c(%rsp)
movss  0x14(%rbp),%xmm3
movaps %xmm3,%xmm0
movaps %xmm3,%xmm6
movss  %xmm3,0x4(%rsp)
mulss  %xmm1,%xmm0
movss  0x3c(%rbp),%xmm7
movaps %xmm0,%xmm3
mulss  %xmm7,%xmm3
xorps  %xmm9,%xmm9
addss  %xmm9,%xmm3
movss  0x14(%r13),%xmm4
mulss  %xmm4,%xmm1
movaps %xmm4,%xmm10
movss  %xmm4,0x14(%rsp)
movss  0x28(%r13),%xmm5
movaps %xmm6,%xmm4
mulss  %xmm5,%xmm4
movaps %xmm5,%xmm8
movss  %xmm5,0x28(%rsp)
movaps %xmm7,%xmm5
mulss  %xmm4,%xmm5
movaps %xmm1,%xmm6
mulss  %xmm7,%xmm6
movss  %xmm7,0x1c(%rsp)
addss  %xmm5,%xmm6
mulss  %xmm2,%xmm0
addss  %xmm6,%xmm0
addss  %xmm9,%xmm0
mulss  %xmm2,%xmm1
mulss  %xmm2,%xmm4
movss  %xmm2,0x24(%rsp)
addss  %xmm1,%xmm4
movaps %xmm10,%xmm1
mulss  %xmm8,%xmm1
movaps %xmm1,%xmm8
mulss  %xmm7,%xmm8
addss  %xmm4,%xmm8
addss  %xmm9,%xmm8
mulss  %xmm2,%xmm1
addss  %xmm9,%xmm1
movss  0x24(%rbp),%xmm15
movss  0x38(%rbp),%xmm9
movaps %xmm15,%xmm2
mulss  %xmm9,%xmm2
movss  0x1c(%rbp),%xmm7
movaps %xmm2,%xmm14
mulss  %xmm7,%xmm14
addss  %xmm3,%xmm14
movss  0x24(%r13),%xmm13
movaps %xmm9,%xmm6
mulss  %xmm13,%xmm6
movss  %xmm13,0x10(%rsp)
movss  0x38(%r13),%xmm3
movaps %xmm15,%xmm5
mulss  %xmm3,%xmm5
movaps %xmm3,%xmm10
movss  %xmm3,0xc(%rsp)
movaps %xmm7,%xmm4
mulss  %xmm5,%xmm4
movaps %xmm6,%xmm3
mulss  %xmm7,%xmm3
movss  %xmm7,0x18(%rsp)
addss  %xmm4,%xmm3
movss  0x1c(%r13),%xmm4
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
addss  %xmm0,%xmm2
mulss  %xmm4,%xmm6
mulss  %xmm4,%xmm5
movss  %xmm4,0x20(%rsp)
addss  %xmm6,%xmm5
mulss  %xmm10,%xmm13
movaps %xmm13,%xmm3
mulss  %xmm7,%xmm3
addss  %xmm5,%xmm3
addss  %xmm8,%xmm3
mulss  %xmm4,%xmm13
addss  %xmm1,%xmm13
movss  0x18(%rbp),%xmm7
movss  0x34(%rbp),%xmm10
movaps %xmm10,%xmm6
mulss  %xmm7,%xmm6
movss  0x2c(%rbp),%xmm0
movaps %xmm6,%xmm12
mulss  %xmm0,%xmm12
addss  %xmm14,%xmm12
movss  0x34(%r13),%xmm14
movaps %xmm7,%xmm5
mulss  %xmm14,%xmm5
movss  0x18(%r13),%xmm1
movaps %xmm10,%xmm8
mulss  %xmm1,%xmm8
movaps %xmm1,%xmm11
movss  %xmm1,0x8(%rsp)
movaps %xmm0,%xmm1
mulss  %xmm8,%xmm1
movaps %xmm5,%xmm4
mulss  %xmm0,%xmm4
addss  %xmm1,%xmm4
movss  0x2c(%r13),%xmm1
mulss  %xmm1,%xmm6
addss  %xmm4,%xmm6
addss  %xmm2,%xmm6
mulss  %xmm1,%xmm5
mulss  %xmm1,%xmm8
addss  %xmm5,%xmm8
movaps %xmm14,%xmm2
mulss  %xmm11,%xmm2
movaps %xmm2,%xmm4
mulss  %xmm0,%xmm4
addss  %xmm8,%xmm4
addss  %xmm3,%xmm4
mulss  %xmm1,%xmm2
addss  %xmm13,%xmm2
movss  0x4(%rsp),%xmm8
movaps %xmm8,%xmm3
mulss  %xmm9,%xmm3
movaps %xmm3,%xmm5
mulss  %xmm0,%xmm5
subss  %xmm5,%xmm12
movss  0x14(%rsp),%xmm13
mulss  %xmm13,%xmm9
movss  0xc(%rsp),%xmm11
movaps %xmm8,%xmm5
mulss  %xmm11,%xmm5
movss  %xmm5,0x4(%rsp)
movaps %xmm0,%xmm8
mulss  %xmm5,%xmm8
movaps %xmm9,%xmm5
mulss  %xmm0,%xmm5
addss  %xmm8,%xmm5
mulss  %xmm1,%xmm3
addss  %xmm5,%xmm3
subss  %xmm3,%xmm6
mulss  %xmm1,%xmm9
movss  0x4(%rsp),%xmm3
mulss  %xmm1,%xmm3
addss  %xmm9,%xmm3
movaps %xmm3,%xmm5
movaps %xmm13,%xmm3
mulss  %xmm11,%xmm3
mulss  %xmm3,%xmm0
addss  %xmm5,%xmm0
subss  %xmm0,%xmm4
mulss  %xmm1,%xmm3
subss  %xmm3,%xmm2
movaps %xmm15,%xmm0
mulss  %xmm7,%xmm0
movaps %xmm0,%xmm1
movss  0x1c(%rsp),%xmm5
mulss  %xmm5,%xmm1
subss  %xmm1,%xmm12
movss  0x10(%rsp),%xmm8
mulss  %xmm8,%xmm7
movss  0x8(%rsp),%xmm9
mulss  %xmm9,%xmm15
movaps %xmm5,%xmm1
mulss  %xmm15,%xmm1
movaps %xmm7,%xmm3
mulss  %xmm5,%xmm3
addss  %xmm1,%xmm3
movss  0x24(%rsp),%xmm1
mulss  %xmm1,%xmm0
addss  %xmm3,%xmm0
subss  %xmm0,%xmm6
mulss  %xmm1,%xmm7
mulss  %xmm1,%xmm15
addss  %xmm7,%xmm15
movaps %xmm8,%xmm3
mulss  %xmm9,%xmm3
movaps %xmm5,%xmm0
mulss  %xmm3,%xmm0
addss  %xmm15,%xmm0
subss  %xmm0,%xmm4
mulss  %xmm1,%xmm3
subss  %xmm3,%xmm2
movaps %xmm10,%xmm0
movss  0x2c(%rsp),%xmm5
mulss  %xmm5,%xmm0
movaps %xmm0,%xmm1
movss  0x18(%rsp),%xmm7
mulss  %xmm7,%xmm1
subss  %xmm1,%xmm12
mulss  %xmm14,%xmm5
movss  0x28(%rsp),%xmm8
mulss  %xmm8,%xmm10
movaps %xmm7,%xmm1
mulss  %xmm10,%xmm1
movaps %xmm5,%xmm3
mulss  %xmm7,%xmm3
addss  %xmm1,%xmm3
movss  0x20(%rsp),%xmm1
mulss  %xmm1,%xmm0
addss  %xmm3,%xmm0
subss  %xmm0,%xmm6
mulss  %xmm1,%xmm5
mulss  %xmm1,%xmm10
addss  %xmm5,%xmm10
mulss  %xmm8,%xmm14
movaps %xmm7,%xmm0
mulss  %xmm14,%xmm0
addss  %xmm10,%xmm0
subss  %xmm0,%xmm4
mulss  %xmm1,%xmm14
subss  %xmm14,%xmm2
movss  %xmm12,0x30(%rsp)
movss  %xmm6,0x34(%rsp)
movss  %xmm4,0x38(%rsp)
movss  %xmm2,0x3c(%rsp)
mov    %rbx,%rdi
mov    $0x1,%esi
mov    $0x9,%edx
mov    $0x1,%ecx
mov    $0x9,%r8d
xor    %eax,%eax
call   1030 <free_matrix@plt>
mov    %r15,%rdi
mov    $0x1,%esi
mov    $0x9,%edx
mov    $0x1,%ecx
mov    $0x9,%r8d
xor    %eax,%eax
call   1030 <free_matrix@plt>
mov    %r14,%rdi
mov    $0x1,%esi
mov    $0x9,%edx
xor    %eax,%eax
call   1040 <free_vector@plt>
lea    0x30(%rsp),%rdi
mov    0x50(%rsp),%rsi
xor    %eax,%eax
call   1080 <FindCubicRoots@plt>
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define i32 @moistiv_epipolar(float* nocapture %0, float* nocapture %1, i32* nocapture %2, float* %3, [4 x float]* nocapture %4, [4 x float]* nocapture %5) {
%7 = alloca [4 x float]
%8 = tail call i32 (i32, i32, i32, i32, ...) bitcast (i32 (...)* @matrix to i32 (i32, i32, i32, i32, ...)*)(i32 1, i32 9, i32 1, i32 9)
%9 = sext i32 %8 to i64
%10 = inttoptr i64 %9 to float**
%11 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @vector to i32 (i32, i32, ...)*)(i32 1, i32 9)
%12 = sext i32 %11 to i64
%13 = tail call i32 (i32, i32, i32, i32, ...) bitcast (i32 (...)* @matrix to i32 (i32, i32, i32, i32, ...)*)(i32 1, i32 9, i32 1, i32 9)
%14 = sext i32 %13 to i64
%15 = bitcast [4 x float]* %7 to i8*
br label %58
16: ; preds = %58
%17 = inttoptr i64 %12 to float*
%18 = getelementptr inbounds float*, float** %10, i64 9
%19 = load float*, float** %18
%20 = getelementptr inbounds float*, float** %10, i64 8
%21 = load float*, float** %20
%22 = getelementptr inbounds float, float* %19, i64 1
store float 0.000000e+00, float* %22
%23 = getelementptr inbounds float, float* %21, i64 1
store float 0.000000e+00, float* %23
%24 = getelementptr inbounds float, float* %19, i64 2
store float 0.000000e+00, float* %24
%25 = getelementptr inbounds float, float* %21, i64 2
store float 0.000000e+00, float* %25
%26 = getelementptr inbounds float, float* %19, i64 3
store float 0.000000e+00, float* %26
%27 = getelementptr inbounds float, float* %21, i64 3
store float 0.000000e+00, float* %27
%28 = getelementptr inbounds float, float* %19, i64 4
store float 0.000000e+00, float* %28
%29 = getelementptr inbounds float, float* %21, i64 4
store float 0.000000e+00, float* %29
%30 = getelementptr inbounds float, float* %19, i64 5
store float 0.000000e+00, float* %30
%31 = getelementptr inbounds float, float* %21, i64 5
store float 0.000000e+00, float* %31
%32 = getelementptr inbounds float, float* %19, i64 6
store float 0.000000e+00, float* %32
%33 = getelementptr inbounds float, float* %21, i64 6
store float 0.000000e+00, float* %33
%34 = getelementptr inbounds float, float* %19, i64 7
store float 0.000000e+00, float* %34
%35 = getelementptr inbounds float, float* %21, i64 7
store float 0.000000e+00, float* %35
%36 = getelementptr inbounds float, float* %19, i64 8
store float 0.000000e+00, float* %36
%37 = getelementptr inbounds float, float* %21, i64 8
store float 0.000000e+00, float* %37
%38 = getelementptr inbounds float, float* %19, i64 9
store float 0.000000e+00, float* %38
%39 = getelementptr inbounds float, float* %21, i64 9
store float 0.000000e+00, float* %39
%40 = inttoptr i64 %14 to float**
%41 = tail call i32 (float**, i32, i32, float*, float**, ...) bitcast (i32 (...)* @svdcmp to i32 (float**, i32, i32, float*, float**, ...)*)(float** %10, i32 9, i32 9, float* %17, float** %40)
%42 = getelementptr inbounds float, float* %17, i64 1
%43 = load float, float* %42
%44 = getelementptr inbounds float, float* %17, i64 2
%45 = load float, float* %44
%46 = fcmp olt float %43, %45
%47 = select i1 %46, i32 1, i32 2
%48 = select i1 %46, i32 2, i32 1
%49 = zext i32 %47 to i64
%50 = getelementptr inbounds float, float* %17, i64 %49
%51 = load float, float* %50
%52 = zext i32 %48 to i64
%53 = getelementptr inbounds float, float* %17, i64 %52
%54 = load float, float* %53
%55 = getelementptr inbounds float, float* %17, i64 3
%56 = load float, float* %55
%57 = fcmp olt float %56, %51
br i1 %57, label %102, label %99
58: ; preds = %6, %58
%59 = phi i64 [ 0, %6 ], [ %69, %58 ]
%60 = getelementptr inbounds i32, i32* %2, i64 %59
%61 = load i32, i32* %60
%62 = shl nsw i32 %61, 1
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds float, float* %0, i64 %63
%65 = load float, float* %64
%66 = getelementptr inbounds float, float* %1, i64 %63
%67 = load float, float* %66
%68 = fmul float %65, %67
%69 = add nuw nsw i64 %59, 1
%70 = getelementptr inbounds float*, float** %10, i64 %69
%71 = load float*, float** %70
%72 = getelementptr inbounds float, float* %71, i64 1
store float %68, float* %72
%73 = or i32 %62, 1
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds float, float* %0, i64 %74
%76 = load float, float* %75
%77 = load float, float* %66
%78 = fmul float %76, %77
%79 = getelementptr inbounds float, float* %71, i64 2
store float %78, float* %79
%80 = load float, float* %66
%81 = getelementptr inbounds float, float* %71, i64 3
store float %80, float* %81
%82 = load float, float* %64
%83 = getelementptr inbounds float, float* %1, i64 %74
%84 = load float, float* %83
%85 = fmul float %82, %84
%86 = getelementptr inbounds float, float* %71, i64 4
store float %85, float* %86
%87 = load float, float* %75
%88 = load float, float* %83
%89 = fmul float %87, %88
%90 = getelementptr inbounds float, float* %71, i64 5
store float %89, float* %90
%91 = load float, float* %83
%92 = getelementptr inbounds float, float* %71, i64 6
store float %91, float* %92
%93 = load float, float* %64
%94 = getelementptr inbounds float, float* %71, i64 7
store float %93, float* %94
%95 = load float, float* %75
%96 = getelementptr inbounds float, float* %71, i64 8
store float %95, float* %96
%97 = getelementptr inbounds float, float* %71, i64 9
store float 1.000000e+00, float* %97
%98 = icmp eq i64 %69, 7
br i1 %98, label %16, label %58
99: ; preds = %16
%100 = fcmp olt float %56, %54
br i1 %100, label %101, label %102
101: ; preds = %99
br label %102
102: ; preds = %16, %101, %99
%103 = phi i32 [ %47, %101 ], [ %47, %99 ], [ 3, %16 ]
%104 = phi i32 [ 3, %101 ], [ %48, %99 ], [ %47, %16 ]
%105 = phi float [ %51, %101 ], [ %51, %99 ], [ %56, %16 ]
%106 = phi float [ %56, %101 ], [ %54, %99 ], [ %51, %16 ]
%107 = getelementptr inbounds float, float* %17, i64 4
%108 = load float, float* %107
%109 = fcmp olt float %108, %105
br i1 %109, label %113, label %110
110: ; preds = %102
%111 = fcmp olt float %108, %106
br i1 %111, label %112, label %113
112: ; preds = %110
br label %113
113: ; preds = %112, %110, %102
%114 = phi i32 [ %103, %112 ], [ %103, %110 ], [ 4, %102 ]
%115 = phi i32 [ 4, %112 ], [ %104, %110 ], [ %103, %102 ]
%116 = phi float [ %105, %112 ], [ %105, %110 ], [ %108, %102 ]
%117 = phi float [ %108, %112 ], [ %106, %110 ], [ %105, %102 ]
%118 = getelementptr inbounds float, float* %17, i64 5
%119 = load float, float* %118
%120 = fcmp olt float %119, %116
br i1 %120, label %124, label %121
121: ; preds = %113
%122 = fcmp olt float %119, %117
br i1 %122, label %123, label %124
123: ; preds = %121
br label %124
124: ; preds = %123, %121, %113
%125 = phi i32 [ %114, %123 ], [ %114, %121 ], [ 5, %113 ]
%126 = phi i32 [ 5, %123 ], [ %115, %121 ], [ %114, %113 ]
%127 = phi float [ %116, %123 ], [ %116, %121 ], [ %119, %113 ]
%128 = phi float [ %119, %123 ], [ %117, %121 ], [ %116, %113 ]
%129 = getelementptr inbounds float, float* %17, i64 6
%130 = load float, float* %129
%131 = fcmp olt float %130, %127
br i1 %131, label %135, label %132
132: ; preds = %124
%133 = fcmp olt float %130, %128
br i1 %133, label %134, label %135
134: ; preds = %132
br label %135
135: ; preds = %134, %132, %124
%136 = phi i32 [ %125, %134 ], [ %125, %132 ], [ 6, %124 ]
%137 = phi i32 [ 6, %134 ], [ %126, %132 ], [ %125, %124 ]
%138 = phi float [ %127, %134 ], [ %127, %132 ], [ %130, %124 ]
%139 = phi float [ %130, %134 ], [ %128, %132 ], [ %127, %124 ]
%140 = getelementptr inbounds float, float* %17, i64 7
%141 = load float, float* %140
%142 = fcmp olt float %141, %138
br i1 %142, label %146, label %143
143: ; preds = %135
%144 = fcmp olt float %141, %139
br i1 %144, label %145, label %146
145: ; preds = %143
br label %146
146: ; preds = %145, %143, %135
%147 = phi i32 [ %136, %145 ], [ %136, %143 ], [ 7, %135 ]
%148 = phi i32 [ 7, %145 ], [ %137, %143 ], [ %136, %135 ]
%149 = phi float [ %138, %145 ], [ %138, %143 ], [ %141, %135 ]
%150 = phi float [ %141, %145 ], [ %139, %143 ], [ %138, %135 ]
%151 = getelementptr inbounds float, float* %17, i64 8
%152 = load float, float* %151
%153 = fcmp olt float %152, %149
br i1 %153, label %157, label %154
154: ; preds = %146
%155 = fcmp olt float %152, %150
br i1 %155, label %156, label %157
156: ; preds = %154
br label %157
157: ; preds = %156, %154, %146
%158 = phi i32 [ %147, %156 ], [ %147, %154 ], [ 8, %146 ]
%159 = phi i32 [ 8, %156 ], [ %148, %154 ], [ %147, %146 ]
%160 = phi float [ %149, %156 ], [ %149, %154 ], [ %152, %146 ]
%161 = phi float [ %152, %156 ], [ %150, %154 ], [ %149, %146 ]
%162 = getelementptr inbounds float, float* %17, i64 9
%163 = load float, float* %162
%164 = fcmp olt float %163, %160
br i1 %164, label %168, label %165
165: ; preds = %157
%166 = fcmp olt float %163, %161
br i1 %166, label %167, label %168
167: ; preds = %165
br label %168
168: ; preds = %167, %165, %157
%169 = phi i32 [ %158, %167 ], [ %158, %165 ], [ 9, %157 ]
%170 = phi i32 [ 9, %167 ], [ %159, %165 ], [ %158, %157 ]
%171 = zext i32 %169 to i64
%172 = zext i32 %170 to i64
%173 = getelementptr inbounds float*, float** %40, i64 1
%174 = load float*, float** %173
%175 = getelementptr inbounds float, float* %174, i64 %171
%176 = load float, float* %175
%177 = getelementptr inbounds [4 x float], [4 x float]* %4, i64 1, i64 1
store float %176, float* %177
%178 = getelementptr inbounds float, float* %174, i64 %172
%179 = load float, float* %178
%180 = fsub float %179, %176
%181 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 1, i64 1
store float %180, float* %181
%182 = getelementptr inbounds float*, float** %40, i64 2
%183 = load float*, float** %182
%184 = getelementptr inbounds float, float* %183, i64 %171
%185 = load float, float* %184
%186 = getelementptr inbounds [4 x float], [4 x float]* %4, i64 1, i64 2
store float %185, float* %186
%187 = getelementptr inbounds float, float* %183, i64 %172
%188 = load float, float* %187
%189 = fsub float %188, %185
%190 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 1, i64 2
store float %189, float* %190
%191 = getelementptr inbounds float*, float** %40, i64 3
%192 = load float*, float** %191
%193 = getelementptr inbounds float, float* %192, i64 %171
%194 = load float, float* %193
%195 = getelementptr inbounds [4 x float], [4 x float]* %4, i64 1, i64 3
store float %194, float* %195
%196 = getelementptr inbounds float, float* %192, i64 %172
%197 = load float, float* %196
%198 = fsub float %197, %194
%199 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 1, i64 3
store float %198, float* %199
%200 = getelementptr inbounds float*, float** %40, i64 4
%201 = load float*, float** %200
%202 = getelementptr inbounds float, float* %201, i64 %171
%203 = load float, float* %202
%204 = getelementptr inbounds [4 x float], [4 x float]* %4, i64 2, i64 1
store float %203, float* %204
%205 = getelementptr inbounds float, float* %201, i64 %172
%206 = load float, float* %205
%207 = fsub float %206, %203
%208 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 2, i64 1
store float %207, float* %208
%209 = getelementptr inbounds float*, float** %40, i64 5
%210 = load float*, float** %209
%211 = getelementptr inbounds float, float* %210, i64 %171
%212 = load float, float* %211
%213 = getelementptr inbounds [4 x float], [4 x float]* %4, i64 2, i64 2
store float %212, float* %213
%214 = getelementptr inbounds float, float* %210, i64 %172
%215 = load float, float* %214
%216 = fsub float %215, %212
%217 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 2, i64 2
store float %216, float* %217
%218 = getelementptr inbounds float*, float** %40, i64 6
%219 = load float*, float** %218
%220 = getelementptr inbounds float, float* %219, i64 %171
%221 = load float, float* %220
%222 = getelementptr inbounds [4 x float], [4 x float]* %4, i64 2, i64 3
store float %221, float* %222
%223 = getelementptr inbounds float, float* %219, i64 %172
%224 = load float, float* %223
%225 = fsub float %224, %221
%226 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 2, i64 3
store float %225, float* %226
%227 = getelementptr inbounds float*, float** %40, i64 7
%228 = load float*, float** %227
%229 = getelementptr inbounds float, float* %228, i64 %171
%230 = load float, float* %229
%231 = getelementptr inbounds [4 x float], [4 x float]* %4, i64 3, i64 1
store float %230, float* %231
%232 = getelementptr inbounds float, float* %228, i64 %172
%233 = load float, float* %232
%234 = fsub float %233, %230
%235 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 3, i64 1
store float %234, float* %235
%236 = getelementptr inbounds float*, float** %40, i64 8
%237 = load float*, float** %236
%238 = getelementptr inbounds float, float* %237, i64 %171
%239 = load float, float* %238
%240 = getelementptr inbounds [4 x float], [4 x float]* %4, i64 3, i64 2
store float %239, float* %240
%241 = getelementptr inbounds float, float* %237, i64 %172
%242 = load float, float* %241
%243 = fsub float %242, %239
%244 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 3, i64 2
store float %243, float* %244
%245 = getelementptr inbounds float*, float** %40, i64 9
%246 = load float*, float** %245
%247 = getelementptr inbounds float, float* %246, i64 %171
%248 = load float, float* %247
%249 = getelementptr inbounds [4 x float], [4 x float]* %4, i64 3, i64 3
store float %248, float* %249
%250 = getelementptr inbounds float, float* %246, i64 %172
%251 = load float, float* %250
%252 = fsub float %251, %248
%253 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 3, i64 3
store float %252, float* %253
%254 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 3
%255 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 2
%256 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 1
%257 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 0
%258 = load float, float* %177
%259 = load float, float* %213
%260 = fmul float %258, %259
%261 = load float, float* %249
%262 = tail call float @llvm.fmuladd.f32(float %260, float %261, float 0.000000e+00)
%263 = load float, float* %181
%264 = fmul float %259, %263
%265 = load float, float* %217
%266 = fmul float %258, %265
%267 = fmul float %261, %266
%268 = tail call float @llvm.fmuladd.f32(float %264, float %261, float %267)
%269 = tail call float @llvm.fmuladd.f32(float %260, float %252, float %268)
%270 = fadd float %269, 0.000000e+00
%271 = fmul float %264, %252
%272 = tail call float @llvm.fmuladd.f32(float %266, float %252, float %271)
%273 = fmul float %263, %265
%274 = tail call float @llvm.fmuladd.f32(float %273, float %261, float %272)
%275 = fadd float %274, 0.000000e+00
%276 = tail call float @llvm.fmuladd.f32(float %273, float %252, float 0.000000e+00)
%277 = load float, float* %204
%278 = load float, float* %240
%279 = fmul float %277, %278
%280 = load float, float* %195
%281 = tail call float @llvm.fmuladd.f32(float %279, float %280, float %262)
%282 = load float, float* %208
%283 = fmul float %278, %282
%284 = load float, float* %244
%285 = fmul float %277, %284
%286 = fmul float %280, %285
%287 = tail call float @llvm.fmuladd.f32(float %283, float %280, float %286)
%288 = load float, float* %199
%289 = tail call float @llvm.fmuladd.f32(float %279, float %288, float %287)
%290 = fadd float %270, %289
%291 = fmul float %283, %288
%292 = tail call float @llvm.fmuladd.f32(float %285, float %288, float %291)
%293 = fmul float %282, %284
%294 = tail call float @llvm.fmuladd.f32(float %293, float %280, float %292)
%295 = fadd float %275, %294
%296 = tail call float @llvm.fmuladd.f32(float %293, float %288, float %276)
%297 = load float, float* %231
%298 = load float, float* %186
%299 = fmul float %297, %298
%300 = load float, float* %222
%301 = tail call float @llvm.fmuladd.f32(float %299, float %300, float %281)
%302 = load float, float* %235
%303 = fmul float %298, %302
%304 = load float, float* %190
%305 = fmul float %297, %304
%306 = fmul float %300, %305
%307 = tail call float @llvm.fmuladd.f32(float %303, float %300, float %306)
%308 = load float, float* %226
%309 = tail call float @llvm.fmuladd.f32(float %299, float %308, float %307)
%310 = fadd float %290, %309
%311 = fmul float %303, %308
%312 = tail call float @llvm.fmuladd.f32(float %305, float %308, float %311)
%313 = fmul float %302, %304
%314 = tail call float @llvm.fmuladd.f32(float %313, float %300, float %312)
%315 = fadd float %295, %314
%316 = tail call float @llvm.fmuladd.f32(float %313, float %308, float %296)
%317 = fneg float %258
%318 = fmul float %278, %317
%319 = tail call float @llvm.fmuladd.f32(float %318, float %300, float %301)
%320 = fmul float %278, %263
%321 = fmul float %258, %284
%322 = fmul float %300, %321
%323 = tail call float @llvm.fmuladd.f32(float %320, float %300, float %322)
%324 = fmul float %258, %278
%325 = tail call float @llvm.fmuladd.f32(float %324, float %308, float %323)
%326 = fsub float %310, %325
%327 = fmul float %320, %308
%328 = tail call float @llvm.fmuladd.f32(float %321, float %308, float %327)
%329 = fmul float %263, %284
%330 = tail call float @llvm.fmuladd.f32(float %329, float %300, float %328)
%331 = fsub float %315, %330
%332 = fneg float %263
%333 = fmul float %284, %332
%334 = tail call float @llvm.fmuladd.f32(float %333, float %308, float %316)
%335 = fneg float %277
%336 = fmul float %298, %335
%337 = tail call float @llvm.fmuladd.f32(float %336, float %261, float %319)
%338 = fmul float %298, %282
%339 = fmul float %277, %304
%340 = fmul float %261, %339
%341 = tail call float @llvm.fmuladd.f32(float %338, float %261, float %340)
%342 = fmul float %277, %298
%343 = tail call float @llvm.fmuladd.f32(float %342, float %252, float %341)
%344 = fsub float %326, %343
%345 = fmul float %338, %252
%346 = tail call float @llvm.fmuladd.f32(float %339, float %252, float %345)
%347 = fmul float %282, %304
%348 = tail call float @llvm.fmuladd.f32(float %347, float %261, float %346)
%349 = fsub float %331, %348
%350 = fneg float %282
%351 = fmul float %304, %350
%352 = tail call float @llvm.fmuladd.f32(float %351, float %252, float %334)
%353 = fneg float %297
%354 = fmul float %259, %353
%355 = tail call float @llvm.fmuladd.f32(float %354, float %280, float %337)
%356 = fmul float %259, %302
%357 = fmul float %297, %265
%358 = fmul float %280, %357
%359 = tail call float @llvm.fmuladd.f32(float %356, float %280, float %358)
%360 = fmul float %297, %259
%361 = tail call float @llvm.fmuladd.f32(float %360, float %288, float %359)
%362 = fsub float %344, %361
%363 = fmul float %356, %288
%364 = tail call float @llvm.fmuladd.f32(float %357, float %288, float %363)
%365 = fmul float %302, %265
%366 = tail call float @llvm.fmuladd.f32(float %365, float %280, float %364)
%367 = fsub float %349, %366
%368 = fneg float %302
%369 = fmul float %265, %368
%370 = tail call float @llvm.fmuladd.f32(float %369, float %288, float %352)
store float %355, float* %257
store float %362, float* %256
store float %367, float* %255
store float %370, float* %254
%371 = tail call i32 (float**, i32, i32, i32, i32, ...) bitcast (i32 (...)* @free_matrix to i32 (float**, i32, i32, i32, i32, ...)*)(float** %10, i32 1, i32 9, i32 1, i32 9)
%372 = tail call i32 (float**, i32, i32, i32, i32, ...) bitcast (i32 (...)* @free_matrix to i32 (float**, i32, i32, i32, i32, ...)*)(float** %40, i32 1, i32 9, i32 1, i32 9)
%373 = tail call i32 (float*, i32, i32, ...) bitcast (i32 (...)* @free_vector to i32 (float*, i32, i32, ...)*)(float* %17, i32 1, i32 9)
%374 = call i32 (float*, float*, ...) bitcast (i32 (...)* @FindCubicRoots to i32 (float*, float*, ...)*)(float* %257, float* %3)
ret i32 %374
}