#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 */
int /*<<< orphan*/ balanc(float **, int);
int /*<<< orphan*/ eigsrt(float *, float **, int);
int /*<<< orphan*/ elmhes(float **, int);
float fabs(float);
int /*<<< orphan*/ free_ivector(int *, int, int);
int /*<<< orphan*/ free_matrix(float **, int, int, int, int);
int /*<<< orphan*/ free_vector(float *, int, int);
int /*<<< orphan*/ hqr(float **, int, float *, float *);
int *ivector(int, int);
int /*<<< orphan*/ lubksb(float **, int, int *, float *);
int /*<<< orphan*/ ludcmp(float **, int, int *, float *);
float **matrix(int, int, int, int);
int /*<<< orphan*/ mtm(float **, float **, float **, int, int, int);
int /*<<< orphan*/ printf(char *, int);
float sqrt(float);
float *vector(int, int);
void poleCompute(float *pole, float **G, float **C, int viewnode, int ndim,
                 int order) {
  int i, j;
  const float etol = 1.0e-15;
  float **R, **RT;
  R = matrix(1, ndim, 1, order);
  RT = matrix(1, order, 1, ndim);
  float **a, *b, d;
  int *indx;
  indx = ivector(1, ndim);
  a = matrix(1, ndim, 1, ndim);
  b = vector(1, ndim);
  for (i = 1; i <= ndim; i++) {
    for (j = 1; j <= ndim; j++) {
      a[i][j] = G[i][j];
    }
    if (i == viewnode)
      b[i] = 1;
    else
      b[i] = 0;
  }
  ludcmp(a, ndim, indx, &d);
  lubksb(a, ndim, indx, b);
  float b_sum = 0;
  for (i = 1; i <= ndim; i++) {
    b_sum += b[i] * b[i];
  }
  float alpha = sqrt(b_sum);
  for (i = 1; i <= ndim; i++) {
    R[i][1] = b[i] / alpha;
  }
  float csum, h = 0;
  for (int iter = 2; iter <= order; iter++) {
    for (i = 1; i <= ndim; i++) {
      csum = 0;
      for (j = 1; j <= ndim; j++) {
        csum += C[i][j] * R[j][iter - 1];
      }
      b[i] = csum;
    }
    lubksb(a, ndim, indx, b);
    for (i = 1; i <= ndim; i++)
      R[i][iter] = b[i];
    for (j = 1; j < iter; j++) {
      h = 0;
      for (i = 1; i <= ndim; i++) {
        h += R[i][j] * R[i][iter];
      }
      for (i = 1; i <= ndim; i++) {
        R[i][iter] -= h * R[i][j];
      }
    }
    b_sum = 0;
    for (i = 1; i <= ndim; i++) {
      b_sum += R[i][iter] * R[i][iter];
    }
    alpha = sqrt(b_sum);
    if (alpha < etol) {
      printf("Break on iteration %d\n", iter);
      order = iter;
      break;
    } else {
      for (i = 1; i <= ndim; i++) {
        R[i][iter] /= alpha;
      }
    }
  }
  for (j = 1; j <= order; j++) {
    for (i = 1; i <= ndim; i++) {
      RT[j][i] = R[i][j];
    }
  }
  float **T, **NG, **NC;
  T = matrix(1, order, 1, ndim);
  NG = matrix(1, order, 1, order);
  NC = matrix(1, order, 1, order);
  mtm(T, RT, G, order, ndim, ndim);
  mtm(NG, T, R, order, order, ndim);
  mtm(T, RT, C, order, ndim, ndim);
  mtm(NC, T, R, order, order, ndim);
  int *indx1;
  float *col, **NGI, **GIC;
  indx1 = ivector(1, order);
  col = vector(1, order);
  NGI = matrix(1, order, 1, order);
  GIC = matrix(1, order, 1, order);
  ludcmp(NG, order, indx1, &d);
  for (j = 1; j <= order; j++) {
    for (i = 1; i <= order; i++)
      col[i] = 0.0;
    col[j] = 1.0;
    lubksb(NG, order, indx1, col);
    for (i = 1; i <= order; i++)
      NGI[i][j] = col[i];
  }
  mtm(GIC, NGI, NC, order, order, order);
  float *wr, *wi;
  wr = vector(1, order);
  wi = vector(1, order);
  balanc(GIC, order);
  elmhes(GIC, order);
  hqr(GIC, order, wr, wi);
  for (i = 1; i <= order; i++)
    wr[i] = fabs(wr[i]);
  eigsrt(wr, GIC, order);
  for (i = 1; i <= order; i++)
    pole[i] = -1.0 / wr[i];
  free_matrix(R, 1, ndim, 1, order);
  free_matrix(RT, 1, order, 1, ndim);
  free_vector(b, 1, ndim);
  free_matrix(a, 1, ndim, 1, ndim);
  free_matrix(T, 1, order, 1, ndim);
  free_matrix(NG, 1, order, 1, order);
  free_matrix(NC, 1, order, 1, order);
  free_vector(col, 1, order);
  free_matrix(NGI, 1, order, 1, order);
  free_matrix(GIC, 1, order, 1, order);
  free_vector(wr, 1, order);
  free_vector(wi, 1, order);
  free_ivector(indx, 1, ndim);
  free_ivector(indx1, 1, order);
}


x86 assembly (clang, -O0):
<poleCompute>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
mov    %r9d,-0x24(%rbp)
movss  0xdd6(%rip),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x20(%rbp),%esi
mov    -0x24(%rbp),%ecx
mov    $0x1,%edx
mov    %edx,%edi
call   10a0 <matrix@plt>
mov    %rax,-0x38(%rbp)
mov    -0x24(%rbp),%esi
mov    -0x20(%rbp),%ecx
mov    $0x1,%edx
mov    %edx,%edi
call   10a0 <matrix@plt>
mov    %rax,-0x40(%rbp)
mov    -0x20(%rbp),%esi
mov    $0x1,%edi
call   10f0 <ivector@plt>
mov    %rax,-0x60(%rbp)
mov    -0x20(%rbp),%esi
mov    -0x20(%rbp),%ecx
mov    $0x1,%edx
mov    %edx,%edi
call   10a0 <matrix@plt>
mov    %rax,-0x48(%rbp)
mov    -0x20(%rbp),%esi
mov    $0x1,%edi
call   10b0 <vector@plt>
mov    %rax,-0x50(%rbp)
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x20(%rbp),%eax
jg     133a <poleCompute+0x13a>
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jg     12f1 <poleCompute+0xf1>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    12ad <poleCompute+0xad>
mov    -0x28(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jne    1317 <poleCompute+0x117>
mov    -0x50(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  0xcf7(%rip),%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    1327 <poleCompute+0x127>
mov    -0x50(%rbp),%rax
movslq -0x28(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    132c <poleCompute+0x12c>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    129a <poleCompute+0x9a>
mov    -0x48(%rbp),%rdi
mov    -0x20(%rbp),%esi
mov    -0x60(%rbp),%rdx
lea    -0x54(%rbp),%rcx
call   1030 <ludcmp@plt>
mov    -0x48(%rbp),%rdi
mov    -0x20(%rbp),%esi
mov    -0x60(%rbp),%rdx
mov    -0x50(%rbp),%rcx
call   1090 <lubksb@plt>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x64(%rbp)
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x20(%rbp),%eax
jg     13b7 <poleCompute+0x1b7>
mov    -0x50(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1371 <poleCompute+0x171>
movss  -0x64(%rbp),%xmm0
call   1100 <sqrt@plt>
movss  %xmm0,-0x68(%rbp)
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x20(%rbp),%eax
jg     140a <poleCompute+0x20a>
mov    -0x50(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x68(%rbp),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  %xmm0,0x4(%rax)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    13cd <poleCompute+0x1cd>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x70(%rbp)
movl   $0x2,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     170b <poleCompute+0x50b>
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x20(%rbp),%eax
jg     14c2 <poleCompute+0x2c2>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x6c(%rbp)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jg     14a2 <poleCompute+0x2a2>
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x74(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x6c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1447 <poleCompute+0x247>
movss  -0x6c(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    142c <poleCompute+0x22c>
mov    -0x48(%rbp),%rdi
mov    -0x20(%rbp),%esi
mov    -0x60(%rbp),%rdx
mov    -0x50(%rbp),%rcx
call   1090 <lubksb@plt>
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x20(%rbp),%eax
jg     1519 <poleCompute+0x319>
mov    -0x50(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x74(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    14dd <poleCompute+0x2dd>
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x74(%rbp),%eax
jge    160f <poleCompute+0x40f>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x70(%rbp)
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x20(%rbp),%eax
jg     1591 <poleCompute+0x391>
mov    -0x38(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x74(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x70(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x70(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    153b <poleCompute+0x33b>
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x20(%rbp),%eax
jg     15fc <poleCompute+0x3fc>
movss  -0x70(%rbp),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x38(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x74(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movd   %xmm0,%edx
xor    $0x80000000,%edx
movd   %edx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1598 <poleCompute+0x398>
jmp    1601 <poleCompute+0x401>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1520 <poleCompute+0x320>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x64(%rbp)
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x20(%rbp),%eax
jg     1674 <poleCompute+0x474>
mov    -0x38(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x74(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x74(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    161e <poleCompute+0x41e>
movss  -0x64(%rbp),%xmm0
call   1100 <sqrt@plt>
movss  %xmm0,-0x68(%rbp)
movss  0x975(%rip),%xmm0
ucomiss -0x68(%rbp),%xmm0
jbe    16af <poleCompute+0x4af>
mov    -0x74(%rbp),%esi
lea    0x971(%rip),%rdi
call   1050 <printf@plt>
mov    -0x74(%rbp),%eax
mov    %eax,-0x24(%rbp)
jmp    170b <poleCompute+0x50b>
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x20(%rbp),%eax
jg     16f3 <poleCompute+0x4f3>
movss  -0x68(%rbp),%xmm1
mov    -0x38(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x74(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    16b6 <poleCompute+0x4b6>
jmp    16f8 <poleCompute+0x4f8>
jmp    16fd <poleCompute+0x4fd>
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    1419 <poleCompute+0x219>
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     177c <poleCompute+0x57c>
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x20(%rbp),%eax
jg     1769 <poleCompute+0x569>
mov    -0x38(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1725 <poleCompute+0x525>
jmp    176e <poleCompute+0x56e>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1712 <poleCompute+0x512>
mov    -0x24(%rbp),%esi
mov    -0x20(%rbp),%ecx
mov    $0x1,%edx
mov    %edx,%edi
call   10a0 <matrix@plt>
mov    %rax,-0x80(%rbp)
mov    -0x24(%rbp),%esi
mov    -0x24(%rbp),%ecx
mov    $0x1,%edx
mov    %edx,%edi
call   10a0 <matrix@plt>
mov    %rax,-0x88(%rbp)
mov    -0x24(%rbp),%esi
mov    -0x24(%rbp),%ecx
mov    $0x1,%edx
mov    %edx,%edi
call   10a0 <matrix@plt>
mov    %rax,-0x90(%rbp)
mov    -0x80(%rbp),%rdi
mov    -0x40(%rbp),%rsi
mov    -0x10(%rbp),%rdx
mov    -0x24(%rbp),%ecx
mov    -0x20(%rbp),%r8d
mov    -0x20(%rbp),%r9d
call   1110 <mtm@plt>
mov    -0x88(%rbp),%rdi
mov    -0x80(%rbp),%rsi
mov    -0x38(%rbp),%rdx
mov    -0x24(%rbp),%ecx
mov    -0x24(%rbp),%r8d
mov    -0x20(%rbp),%r9d
call   1110 <mtm@plt>
mov    -0x80(%rbp),%rdi
mov    -0x40(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x24(%rbp),%ecx
mov    -0x20(%rbp),%r8d
mov    -0x20(%rbp),%r9d
call   1110 <mtm@plt>
mov    -0x90(%rbp),%rdi
mov    -0x80(%rbp),%rsi
mov    -0x38(%rbp),%rdx
mov    -0x24(%rbp),%ecx
mov    -0x24(%rbp),%r8d
mov    -0x20(%rbp),%r9d
call   1110 <mtm@plt>
mov    -0x24(%rbp),%esi
mov    $0x1,%edi
call   10f0 <ivector@plt>
mov    %rax,-0x98(%rbp)
mov    -0x24(%rbp),%esi
mov    $0x1,%edi
call   10b0 <vector@plt>
mov    %rax,-0xa0(%rbp)
mov    -0x24(%rbp),%esi
mov    -0x24(%rbp),%ecx
mov    $0x1,%edx
mov    %edx,%edi
call   10a0 <matrix@plt>
mov    %rax,-0xa8(%rbp)
mov    -0x24(%rbp),%esi
mov    -0x24(%rbp),%ecx
mov    $0x1,%edx
mov    %edx,%edi
call   10a0 <matrix@plt>
mov    %rax,-0xb0(%rbp)
mov    -0x88(%rbp),%rdi
mov    -0x24(%rbp),%esi
mov    -0x98(%rbp),%rdx
lea    -0x54(%rbp),%rcx
call   1030 <ludcmp@plt>
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     1986 <poleCompute+0x786>
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     18f5 <poleCompute+0x6f5>
mov    -0xa0(%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    18c8 <poleCompute+0x6c8>
mov    -0xa0(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  0x6fc(%rip),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x88(%rbp),%rdi
mov    -0x24(%rbp),%esi
mov    -0x98(%rbp),%rdx
mov    -0xa0(%rbp),%rcx
call   1090 <lubksb@plt>
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     1973 <poleCompute+0x773>
mov    -0xa0(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0xa8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1931 <poleCompute+0x731>
jmp    1978 <poleCompute+0x778>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    18b5 <poleCompute+0x6b5>
mov    -0xb0(%rbp),%rdi
mov    -0xa8(%rbp),%rsi
mov    -0x90(%rbp),%rdx
mov    -0x24(%rbp),%ecx
mov    -0x24(%rbp),%r8d
mov    -0x24(%rbp),%r9d
call   1110 <mtm@plt>
mov    -0x24(%rbp),%esi
mov    $0x1,%edi
call   10b0 <vector@plt>
mov    %rax,-0xb8(%rbp)
mov    -0x24(%rbp),%esi
mov    $0x1,%edi
call   10b0 <vector@plt>
mov    %rax,-0xc0(%rbp)
mov    -0xb0(%rbp),%rdi
mov    -0x24(%rbp),%esi
call   1120 <balanc@plt>
mov    -0xb0(%rbp),%rdi
mov    -0x24(%rbp),%esi
call   10c0 <elmhes@plt>
mov    -0xb0(%rbp),%rdi
mov    -0x24(%rbp),%esi
mov    -0xb8(%rbp),%rdx
mov    -0xc0(%rbp),%rcx
call   1070 <hqr@plt>
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     1a54 <poleCompute+0x854>
mov    -0xb8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1080 <fabs@plt>
mov    -0xb8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1a15 <poleCompute+0x815>
mov    -0xb8(%rbp),%rdi
mov    -0xb0(%rbp),%rsi
mov    -0x24(%rbp),%edx
call   10d0 <eigsrt@plt>
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     1abc <poleCompute+0x8bc>
mov    -0xb8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x56f(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1a71 <poleCompute+0x871>
mov    -0x38(%rbp),%rdi
mov    -0x20(%rbp),%edx
mov    -0x24(%rbp),%r8d
mov    $0x1,%ecx
mov    %ecx,%esi
call   1040 <free_matrix@plt>
mov    -0x40(%rbp),%rdi
mov    -0x24(%rbp),%edx
mov    -0x20(%rbp),%r8d
mov    $0x1,%ecx
mov    %ecx,%esi
call   1040 <free_matrix@plt>
mov    -0x50(%rbp),%rdi
mov    -0x20(%rbp),%edx
mov    $0x1,%esi
call   1060 <free_vector@plt>
mov    -0x48(%rbp),%rdi
mov    -0x20(%rbp),%edx
mov    -0x20(%rbp),%r8d
mov    $0x1,%ecx
mov    %ecx,%esi
call   1040 <free_matrix@plt>
mov    -0x80(%rbp),%rdi
mov    -0x24(%rbp),%edx
mov    -0x20(%rbp),%r8d
mov    $0x1,%ecx
mov    %ecx,%esi
call   1040 <free_matrix@plt>
mov    -0x88(%rbp),%rdi
mov    -0x24(%rbp),%edx
mov    -0x24(%rbp),%r8d
mov    $0x1,%ecx
mov    %ecx,%esi
call   1040 <free_matrix@plt>
mov    -0x90(%rbp),%rdi
mov    -0x24(%rbp),%edx
mov    -0x24(%rbp),%r8d
mov    $0x1,%ecx
mov    %ecx,%esi
call   1040 <free_matrix@plt>
mov    -0xa0(%rbp),%rdi
mov    -0x24(%rbp),%edx
mov    $0x1,%esi
call   1060 <free_vector@plt>
mov    -0xa8(%rbp),%rdi
mov    -0x24(%rbp),%edx
mov    -0x24(%rbp),%r8d
mov    $0x1,%ecx
mov    %ecx,%esi
call   1040 <free_matrix@plt>
mov    -0xb0(%rbp),%rdi
mov    -0x24(%rbp),%edx
mov    -0x24(%rbp),%r8d
mov    $0x1,%ecx
mov    %ecx,%esi
call   1040 <free_matrix@plt>
mov    -0xb8(%rbp),%rdi
mov    -0x24(%rbp),%edx
mov    $0x1,%esi
call   1060 <free_vector@plt>
mov    -0xc0(%rbp),%rdi
mov    -0x24(%rbp),%edx
mov    $0x1,%esi
call   1060 <free_vector@plt>
mov    -0x60(%rbp),%rdi
mov    -0x20(%rbp),%edx
mov    $0x1,%esi
call   10e0 <free_ivector@plt>
mov    -0x98(%rbp),%rdi
mov    -0x24(%rbp),%edx
mov    $0x1,%esi
call   10e0 <free_ivector@plt>
add    $0xc0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<poleCompute>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x98,%rsp
mov    %r9d,%r12d
mov    %r8d,%ebp
mov    %ecx,%r14d
mov    %rdx,0x10(%rsp)
mov    %rsi,0x30(%rsp)
mov    %rdi,0x88(%rsp)
mov    $0x1,%edi
mov    %r8d,%esi
mov    $0x1,%edx
mov    %r9d,%ecx
call   10a0 <matrix@plt>
mov    %rax,%rbx
mov    $0x1,%edi
mov    %r12d,%esi
mov    $0x1,%edx
mov    %ebp,%ecx
call   10a0 <matrix@plt>
mov    %rax,%r13
mov    $0x1,%edi
mov    %ebp,%esi
call   10f0 <ivector@plt>
mov    %rax,%r15
mov    $0x1,%edi
mov    %ebp,%esi
mov    $0x1,%edx
mov    %ebp,%ecx
call   10a0 <matrix@plt>
mov    %rax,0x28(%rsp)
mov    $0x1,%edi
mov    %ebp,%esi
call   10b0 <vector@plt>
mov    %rbp,%rsi
test   %esi,%esi
mov    %rbp,0x18(%rsp)
mov    %rax,0x8(%rsp)
mov    %r12,0x38(%rsp)
mov    %r15,0x50(%rsp)
mov    %r13,0x48(%rsp)
jle    151a <poleCompute+0x31a>
mov    %esi,%r15d
lea    0x1(%r15),%r13
mov    %r14d,%r12d
lea    -0x8(%r15),%r9
mov    %r9,%r10
shr    $0x3,%r10
add    $0x1,%r10
mov    %r15d,%r11d
and    $0xfffffff8,%r11d
lea    0x1(%r11),%rax
mov    %rax,0x20(%rsp)
mov    %r10d,%r14d
and    $0x3,%r14d
and    $0xfffffffffffffffc,%r10
mov    $0x1,%r8d
movss  0x1d0c(%rip),%xmm0
mov    0x28(%rsp),%rdi
jmp    131d <poleCompute+0x11d>
nopl   0x0(%rax,%rax,1)
mov    0x8(%rsp),%rax
movss  %xmm1,(%rax,%r8,4)
add    $0x1,%r8
cmp    %r13,%r8
mov    0x28(%rsp),%rdi
je     14ab <poleCompute+0x2ab>
mov    0x30(%rsp),%rax
mov    (%rax,%r8,8),%rcx
mov    (%rdi,%r8,8),%rsi
mov    $0x1,%edx
cmp    $0x8,%r15d
jb     1420 <poleCompute+0x220>
lea    0x4(%rsi),%rax
lea    (%rcx,%r13,4),%rdx
cmp    %rdx,%rax
jae    135c <poleCompute+0x15c>
lea    (%rsi,%r13,4),%rax
lea    0x4(%rcx),%rbp
mov    $0x1,%edx
cmp    %rax,%rbp
jb     1420 <poleCompute+0x220>
cmp    $0x18,%r9
jae    1366 <poleCompute+0x166>
xor    %edx,%edx
jmp    13ca <poleCompute+0x1ca>
mov    %r10,%rax
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movups 0x4(%rcx,%rdx,4),%xmm1
movups 0x14(%rcx,%rdx,4),%xmm2
movups %xmm1,0x4(%rsi,%rdx,4)
movups %xmm2,0x14(%rsi,%rdx,4)
movups 0x24(%rcx,%rdx,4),%xmm1
movups 0x34(%rcx,%rdx,4),%xmm2
movups %xmm1,0x24(%rsi,%rdx,4)
movups %xmm2,0x34(%rsi,%rdx,4)
movups 0x44(%rcx,%rdx,4),%xmm1
movups 0x54(%rcx,%rdx,4),%xmm2
movups %xmm1,0x44(%rsi,%rdx,4)
movups %xmm2,0x54(%rsi,%rdx,4)
movups 0x64(%rcx,%rdx,4),%xmm1
movups 0x74(%rcx,%rdx,4),%xmm2
movups %xmm1,0x64(%rsi,%rdx,4)
movups %xmm2,0x74(%rsi,%rdx,4)
add    $0x20,%rdx
add    $0xfffffffffffffffc,%rax
jne    1370 <poleCompute+0x170>
test   %r14,%r14
je     1408 <poleCompute+0x208>
mov    %r14,%rax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    0x0(,%rdx,4),%rbp
or     $0x4,%rbp
movups (%rcx,%rbp,1),%xmm1
movups 0x10(%rcx,%rbp,1),%xmm2
movups %xmm1,(%rsi,%rbp,1)
movups %xmm2,0x10(%rsi,%rbp,1)
add    $0x8,%rdx
add    $0xffffffffffffffff,%rax
jne    13e0 <poleCompute+0x1e0>
mov    0x20(%rsp),%rdx
cmp    %r11,%r15
je     1497 <poleCompute+0x297>
cs nopw 0x0(%rax,%rax,1)
mov    %r13d,%ebp
sub    %edx,%ebp
mov    %rdx,%rax
not    %rax
add    %r13,%rax
and    $0x3,%rbp
je     1454 <poleCompute+0x254>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%rcx,%rdx,4),%xmm1
movss  %xmm1,(%rsi,%rdx,4)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rbp
jne    1440 <poleCompute+0x240>
cmp    $0x3,%rax
jb     1497 <poleCompute+0x297>
nopw   0x0(%rax,%rax,1)
movss  (%rcx,%rdx,4),%xmm1
movss  %xmm1,(%rsi,%rdx,4)
movss  0x4(%rcx,%rdx,4),%xmm1
movss  %xmm1,0x4(%rsi,%rdx,4)
movss  0x8(%rcx,%rdx,4),%xmm1
movss  %xmm1,0x8(%rsi,%rdx,4)
movss  0xc(%rcx,%rdx,4),%xmm1
movss  %xmm1,0xc(%rsi,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%r13
jne    1460 <poleCompute+0x260>
movaps %xmm0,%xmm1
cmp    %r12,%r8
je     1300 <poleCompute+0x100>
xorps  %xmm1,%xmm1
jmp    1300 <poleCompute+0x100>
lea    0x44(%rsp),%rcx
mov    %rdi,%r12
mov    0x18(%rsp),%rbp
mov    %ebp,%esi
mov    0x50(%rsp),%r14
mov    %r14,%rdx
call   1030 <ludcmp@plt>
mov    %r12,%rdi
mov    %ebp,%esi
mov    %r14,%rdx
mov    0x8(%rsp),%rcx
call   1090 <lubksb@plt>
mov    %rbp,%r11
test   %r11d,%r11d
mov    0x38(%rsp),%r12
mov    0x10(%rsp),%r8
jle    1675 <poleCompute+0x475>
add    $0xfffffffffffffffe,%r13
mov    %r15d,%eax
and    $0x3,%eax
cmp    $0x3,%r13
jae    1554 <poleCompute+0x354>
xorps  %xmm0,%xmm0
mov    $0x1,%ecx
mov    0x8(%rsp),%rsi
test   %rax,%rax
jne    15ba <poleCompute+0x3ba>
jmp    15d6 <poleCompute+0x3d6>
lea    0x44(%rsp),%rcx
mov    0x28(%rsp),%rbp
mov    %rbp,%rdi
mov    %r15,%rdx
mov    %rax,%r14
call   1030 <ludcmp@plt>
mov    %rbp,%rdi
mov    0x18(%rsp),%rsi
mov    %r15,%rdx
mov    %r14,%rcx
call   1090 <lubksb@plt>
mov    0x18(%rsp),%r11
mov    0x10(%rsp),%r8
jmp    1675 <poleCompute+0x475>
mov    %r15d,%edx
and    $0xfffffffc,%edx
xorps  %xmm0,%xmm0
xor    %ecx,%ecx
mov    0x8(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  0x4(%rsi,%rcx,4),%xmm1
movss  0x8(%rsi,%rcx,4),%xmm2
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
mulss  %xmm2,%xmm2
addss  %xmm1,%xmm2
movss  0xc(%rsi,%rcx,4),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm2,%xmm1
movss  0x10(%rsi,%rcx,4),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
add    $0x4,%rcx
cmp    %rcx,%rdx
jne    1570 <poleCompute+0x370>
add    $0x1,%rcx
test   %rax,%rax
je     15d6 <poleCompute+0x3d6>
lea    (%rsi,%rcx,4),%rcx
xor    %edx,%edx
movss  (%rcx,%rdx,4),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm1,%xmm0
add    $0x1,%rdx
cmp    %rdx,%rax
jne    15c0 <poleCompute+0x3c0>
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     15ec <poleCompute+0x3ec>
sqrtss %xmm0,%xmm0
test   %r11d,%r11d
jg     1600 <poleCompute+0x400>
jmp    1675 <poleCompute+0x475>
call   1100 <sqrt@plt>
mov    0x10(%rsp),%r8
mov    0x18(%rsp),%r11
test   %r11d,%r11d
jle    1675 <poleCompute+0x475>
test   %r13,%r13
je     2365 <poleCompute+0x1165>
mov    %r15d,%ecx
and    $0xfffffffe,%ecx
neg    %rcx
mov    $0x1,%eax
mov    0x8(%rsp),%rsi
nopl   0x0(%rax)
movss  (%rsi,%rax,4),%xmm1
divss  %xmm0,%xmm1
mov    (%rbx,%rax,8),%rdx
movss  %xmm1,0x4(%rdx)
movss  0x4(%rsi,%rax,4),%xmm1
divss  %xmm0,%xmm1
mov    0x8(%rbx,%rax,8),%rdx
movss  %xmm1,0x4(%rdx)
lea    (%rcx,%rax,1),%rdx
add    $0x2,%rdx
add    $0x2,%rax
cmp    $0x1,%rdx
jne    1620 <poleCompute+0x420>
test   $0x1,%r15b
je     1675 <poleCompute+0x475>
mov    0x8(%rsp),%rcx
movss  (%rcx,%rax,4),%xmm1
divss  %xmm0,%xmm1
mov    (%rbx,%rax,8),%rax
movss  %xmm1,0x4(%rax)
cmp    $0x2,%r12d
jl     1bde <poleCompute+0x9de>
lea    0x1(%r11),%r9d
lea    0x1(%r12),%eax
mov    %rax,0x78(%rsp)
lea    -0x1(%r9),%rbp
lea    -0x2(%r9),%r10
mov    %ebp,%r13d
and    $0x3,%r13d
mov    %rbp,%r15
and    $0xfffffffffffffffc,%r15
mov    %rbp,%r12
and    $0xfffffffffffffffe,%r12
neg    %r12
mov    $0x2,%r14d
mov    0x8(%rsp),%rcx
mov    %r9,0x58(%rsp)
mov    %r10,0x20(%rsp)
mov    %rbp,0x70(%rsp)
jmp    16df <poleCompute+0x4df>
nopl   0x0(%rax)
add    $0x1,%r14
cmp    0x78(%rsp),%r14
je     1bd9 <poleCompute+0x9d9>
test   %r11d,%r11d
jle    18b0 <poleCompute+0x6b0>
mov    $0x1,%eax
jmp    1702 <poleCompute+0x502>
nop
movss  %xmm0,(%rcx,%rax,4)
add    $0x1,%rax
cmp    %r9,%rax
je     17d0 <poleCompute+0x5d0>
mov    (%r8,%rax,8),%rbp
xorps  %xmm0,%xmm0
mov    $0x1,%edx
cmp    $0x3,%r10
jb     1785 <poleCompute+0x585>
xorps  %xmm0,%xmm0
xor    %edx,%edx
nopl   0x0(%rax)
movss  0x4(%rbp,%rdx,4),%xmm1
movss  0x8(%rbp,%rdx,4),%xmm2
mov    0x8(%rbx,%rdx,8),%rsi
mov    0x10(%rbx,%rdx,8),%rdi
mulss  -0x4(%rsi,%r14,4),%xmm1
addss  %xmm0,%xmm1
mulss  -0x4(%rdi,%r14,4),%xmm2
addss  %xmm1,%xmm2
movss  0xc(%rbp,%rdx,4),%xmm1
mov    0x18(%rbx,%rdx,8),%rsi
mulss  -0x4(%rsi,%r14,4),%xmm1
movss  0x10(%rbp,%rdx,4),%xmm0
mov    0x20(%rbx,%rdx,8),%rsi
mulss  -0x4(%rsi,%r14,4),%xmm0
addss  %xmm2,%xmm1
addss  %xmm1,%xmm0
add    $0x4,%rdx
cmp    %rdx,%r15
jne    1720 <poleCompute+0x520>
add    $0x1,%rdx
test   %r13,%r13
je     16f0 <poleCompute+0x4f0>
lea    (%rbx,%rdx,8),%rsi
lea    0x0(%rbp,%rdx,4),%rbp
xor    %edx,%edx
nopl   0x0(%rax)
movss  0x0(%rbp,%rdx,4),%xmm1
mov    (%rsi,%rdx,8),%rdi
mulss  -0x4(%rdi,%r14,4),%xmm1
addss  %xmm1,%xmm0
add    $0x1,%rdx
cmp    %rdx,%r13
jne    17a0 <poleCompute+0x5a0>
jmp    16f0 <poleCompute+0x4f0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x28(%rsp),%rdi
mov    %r11d,%esi
mov    0x50(%rsp),%rdx
call   1090 <lubksb@plt>
movaps 0x1827(%rip),%xmm3
mov    0x20(%rsp),%r10
mov    0x18(%rsp),%r11
test   %r11d,%r11d
mov    0x70(%rsp),%rbp
jle    18d3 <poleCompute+0x6d3>
mov    $0x1,%eax
cmp    $0x3,%r10
jb     1871 <poleCompute+0x671>
xor    %eax,%eax
mov    0x8(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  0x4(%rdx,%rax,4),%xmm0
mov    0x8(%rbx,%rax,8),%rcx
movss  %xmm0,(%rcx,%r14,4)
movss  0x8(%rdx,%rax,4),%xmm0
mov    0x10(%rbx,%rax,8),%rcx
movss  %xmm0,(%rcx,%r14,4)
movss  0xc(%rdx,%rax,4),%xmm0
mov    0x18(%rbx,%rax,8),%rcx
movss  %xmm0,(%rcx,%r14,4)
movss  0x10(%rdx,%rax,4),%xmm0
mov    0x20(%rbx,%rax,8),%rcx
movss  %xmm0,(%rcx,%r14,4)
add    $0x4,%rax
cmp    %rax,%r15
jne    1820 <poleCompute+0x620>
add    $0x1,%rax
test   $0x3,%bpl
je     18d3 <poleCompute+0x6d3>
lea    (%rbx,%rax,8),%rcx
mov    0x8(%rsp),%rdx
lea    (%rdx,%rax,4),%rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
movss  (%rax,%rdx,4),%xmm0
mov    (%rcx,%rdx,8),%rsi
movss  %xmm0,(%rsi,%r14,4)
add    $0x1,%rdx
cmp    %rdx,%r13
jne    1890 <poleCompute+0x690>
jmp    18d3 <poleCompute+0x6d3>
nopw   0x0(%rax,%rax,1)
mov    0x28(%rsp),%rdi
mov    %r11d,%esi
mov    0x50(%rsp),%rdx
call   1090 <lubksb@plt>
movaps 0x1747(%rip),%xmm3
mov    0x20(%rsp),%r10
mov    0x18(%rsp),%r11
mov    $0x1,%eax
jmp    18ed <poleCompute+0x6ed>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rax
cmp    %r14,%rax
je     1a60 <poleCompute+0x860>
test   %r11d,%r11d
jle    18e0 <poleCompute+0x6e0>
xorps  %xmm0,%xmm0
cmp    $0x3,%r10
jae    1910 <poleCompute+0x710>
mov    $0x1,%ecx
test   $0x3,%bpl
jne    1983 <poleCompute+0x783>
jmp    19ac <poleCompute+0x7ac>
nop
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x8(%rbx,%rcx,8),%rdx
mov    0x10(%rbx,%rcx,8),%rsi
movss  (%rdx,%rax,4),%xmm1
mulss  (%rdx,%r14,4),%xmm1
addss  %xmm0,%xmm1
movss  (%rsi,%rax,4),%xmm2
mulss  (%rsi,%r14,4),%xmm2
addss  %xmm1,%xmm2
mov    0x18(%rbx,%rcx,8),%rdx
movss  (%rdx,%rax,4),%xmm1
mulss  (%rdx,%r14,4),%xmm1
mov    0x20(%rbx,%rcx,8),%rdx
movss  (%rdx,%rax,4),%xmm0
mulss  (%rdx,%r14,4),%xmm0
addss  %xmm2,%xmm1
addss  %xmm1,%xmm0
add    $0x4,%rcx
cmp    %rcx,%r15
jne    1920 <poleCompute+0x720>
add    $0x1,%rcx
test   $0x3,%bpl
je     19ac <poleCompute+0x7ac>
lea    (%rbx,%rcx,8),%rcx
xor    %edx,%edx
nopl   0x0(%rax)
mov    (%rcx,%rdx,8),%rsi
movss  (%rsi,%rax,4),%xmm1
mulss  (%rsi,%r14,4),%xmm1
addss  %xmm1,%xmm0
add    $0x1,%rdx
cmp    %rdx,%r13
jne    1990 <poleCompute+0x790>
test   %r11d,%r11d
jle    18e0 <poleCompute+0x6e0>
xorps  %xmm3,%xmm0
mov    $0x1,%ecx
test   %r10,%r10
je     1a15 <poleCompute+0x815>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%rbx,%rcx,8),%rdx
movss  (%rdx,%rax,4),%xmm1
mulss  %xmm0,%xmm1
addss  (%rdx,%r14,4),%xmm1
movss  %xmm1,(%rdx,%r14,4)
mov    0x8(%rbx,%rcx,8),%rdx
movss  (%rdx,%rax,4),%xmm1
mulss  %xmm0,%xmm1
addss  (%rdx,%r14,4),%xmm1
movss  %xmm1,(%rdx,%r14,4)
lea    (%r12,%rcx,1),%rdx
add    $0x2,%rdx
add    $0x2,%rcx
cmp    $0x1,%rdx
jne    19d0 <poleCompute+0x7d0>
test   $0x1,%bpl
je     1a30 <poleCompute+0x830>
mov    (%rbx,%rcx,8),%rcx
mulss  (%rcx,%rax,4),%xmm0
addss  (%rcx,%r14,4),%xmm0
movss  %xmm0,(%rcx,%r14,4)
add    $0x1,%rax
cmp    %r14,%rax
jne    18ed <poleCompute+0x6ed>
xorps  %xmm0,%xmm0
test   %r11d,%r11d
jle    1a63 <poleCompute+0x863>
cmp    $0x3,%r10
jae    1b2e <poleCompute+0x92e>
mov    $0x1,%eax
test   $0x3,%bpl
jne    1b93 <poleCompute+0x993>
jmp    1a63 <poleCompute+0x863>
xorps  %xmm0,%xmm0
ucomiss 0x15a2(%rip),%xmm0
jb     1a80 <poleCompute+0x880>
sqrtss %xmm0,%xmm0
jmp    1a8f <poleCompute+0x88f>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
call   1100 <sqrt@plt>
mov    0x20(%rsp),%r10
mov    0x18(%rsp),%r11
mov    0x8(%rsp),%rcx
mov    0x10(%rsp),%r8
mov    0x58(%rsp),%r9
movss  0x155e(%rip),%xmm1
ucomiss %xmm0,%xmm1
ja     1bc0 <poleCompute+0x9c0>
test   %r11d,%r11d
jle    16d0 <poleCompute+0x4d0>
mov    $0x1,%eax
test   %r10,%r10
je     1b0b <poleCompute+0x90b>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%rbx,%rax,8),%rdx
movss  (%rdx,%r14,4),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,(%rdx,%r14,4)
mov    0x8(%rbx,%rax,8),%rdx
movss  (%rdx,%r14,4),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,(%rdx,%r14,4)
lea    (%r12,%rax,1),%rdx
add    $0x2,%rdx
add    $0x2,%rax
cmp    $0x1,%rdx
jne    1ad0 <poleCompute+0x8d0>
test   $0x1,%bpl
je     16d0 <poleCompute+0x4d0>
mov    (%rbx,%rax,8),%rax
movss  (%rax,%r14,4),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,(%rax,%r14,4)
jmp    16d0 <poleCompute+0x4d0>
xor    %eax,%eax
mov    0x8(%rbx,%rax,8),%rcx
mov    0x10(%rbx,%rax,8),%rdx
movss  (%rcx,%r14,4),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
movss  (%rdx,%r14,4),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
mov    0x18(%rbx,%rax,8),%rcx
movss  (%rcx,%r14,4),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
mov    0x20(%rbx,%rax,8),%rcx
movss  (%rcx,%r14,4),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
add    $0x4,%rax
cmp    %rax,%r15
jne    1b30 <poleCompute+0x930>
add    $0x1,%rax
test   $0x3,%bpl
je     1a63 <poleCompute+0x863>
lea    (%rbx,%rax,8),%rax
xor    %ecx,%ecx
nopl   0x0(%rax)
mov    (%rax,%rcx,8),%rdx
movss  (%rdx,%r14,4),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm1,%xmm0
add    $0x1,%rcx
cmp    %rcx,%r13
jne    1ba0 <poleCompute+0x9a0>
jmp    1a63 <poleCompute+0x863>
lea    0x1479(%rip),%rdi
mov    %r14d,%esi
call   1050 <printf@plt>
mov    0x18(%rsp),%r11
mov    %r14d,%r12d
jmp    1bde <poleCompute+0x9de>
mov    0x38(%rsp),%r12
mov    0x48(%rsp),%r14
test   %r12d,%r12d
jle    1ccd <poleCompute+0xacd>
lea    0x1(%r11),%r8d
lea    0x1(%r12),%r9d
lea    -0x1(%r8),%r10
add    $0xfffffffffffffffe,%r8
mov    %r10d,%esi
and    $0x3,%esi
and    $0xfffffffffffffffc,%r10
mov    $0x1,%edi
jmp    1c1d <poleCompute+0xa1d>
xchg   %ax,%ax
add    $0x1,%rdi
cmp    %r9,%rdi
je     1ccd <poleCompute+0xacd>
test   %r11d,%r11d
jle    1c10 <poleCompute+0xa10>
mov    (%r14,%rdi,8),%rbp
mov    $0x1,%eax
cmp    $0x3,%r8
jb     1c8d <poleCompute+0xa8d>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x8(%rbx,%rax,8),%rcx
movss  (%rcx,%rdi,4),%xmm0
movss  %xmm0,0x4(%rbp,%rax,4)
mov    0x10(%rbx,%rax,8),%rcx
movss  (%rcx,%rdi,4),%xmm0
movss  %xmm0,0x8(%rbp,%rax,4)
mov    0x18(%rbx,%rax,8),%rcx
movss  (%rcx,%rdi,4),%xmm0
movss  %xmm0,0xc(%rbp,%rax,4)
mov    0x20(%rbx,%rax,8),%rcx
movss  (%rcx,%rdi,4),%xmm0
movss  %xmm0,0x10(%rbp,%rax,4)
add    $0x4,%rax
cmp    %rax,%r10
jne    1c40 <poleCompute+0xa40>
add    $0x1,%rax
test   %rsi,%rsi
je     1c10 <poleCompute+0xa10>
lea    0x0(%rbp,%rax,4),%rbp
lea    (%rbx,%rax,8),%rax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%rax,%rcx,8),%rdx
movss  (%rdx,%rdi,4),%xmm0
movss  %xmm0,0x0(%rbp,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rsi
jne    1cb0 <poleCompute+0xab0>
jmp    1c10 <poleCompute+0xa10>
mov    $0x1,%edi
mov    %r12d,%esi
mov    $0x1,%edx
mov    %r11d,%ecx
mov    %r11,%rbp
call   10a0 <matrix@plt>
mov    %rax,%r15
mov    $0x1,%edi
mov    %r12d,%esi
mov    $0x1,%edx
mov    %r12d,%ecx
call   10a0 <matrix@plt>
mov    %rax,%r13
mov    %rax,0x20(%rsp)
mov    $0x1,%edi
mov    %r12d,%esi
mov    $0x1,%edx
mov    %r12d,%ecx
call   10a0 <matrix@plt>
mov    %rax,0x68(%rsp)
mov    %r15,%rdi
mov    %r14,%rsi
mov    0x30(%rsp),%rdx
mov    %r12d,%ecx
mov    %ebp,%r8d
mov    %ebp,%r9d
call   1110 <mtm@plt>
mov    %r13,%rdi
mov    %r15,%rsi
mov    %rbx,%rdx
mov    %r12d,%ecx
mov    %r12d,%r8d
mov    %ebp,%r9d
call   1110 <mtm@plt>
mov    %r15,%rdi
mov    %r14,%rsi
mov    0x10(%rsp),%rdx
mov    %r12d,%ecx
mov    %ebp,%r8d
mov    %ebp,%r9d
call   1110 <mtm@plt>
mov    0x68(%rsp),%rdi
mov    %r15,0x90(%rsp)
mov    %r15,%rsi
mov    %rbx,%rdx
mov    %r12d,%ecx
mov    %r12d,%r8d
mov    %ebp,%r9d
call   1110 <mtm@plt>
mov    $0x1,%edi
mov    %r12d,%esi
call   10f0 <ivector@plt>
mov    %rax,%r14
mov    $0x1,%edi
mov    %r12d,%esi
call   10b0 <vector@plt>
mov    %rax,%r13
mov    $0x1,%edi
mov    %r12d,%esi
mov    $0x1,%edx
mov    %r12d,%ecx
call   10a0 <matrix@plt>
mov    %rax,%rbp
mov    $0x1,%edi
mov    %r12d,%esi
mov    $0x1,%edx
mov    %r12d,%ecx
call   10a0 <matrix@plt>
mov    %rax,0x60(%rsp)
lea    0x44(%rsp),%rcx
mov    0x20(%rsp),%rdi
mov    %r12d,%esi
mov    %r14,0x30(%rsp)
mov    %r14,%rdx
call   1030 <ludcmp@plt>
mov    %r12d,%eax
mov    %rax,0x80(%rsp)
mov    %r12,0x38(%rsp)
test   %r12d,%r12d
jle    1f4d <poleCompute+0xd4d>
lea    0x4(%r13),%rax
mov    %rax,0x10(%rsp)
mov    0x80(%rsp),%r14
lea    0x0(,%r14,4),%rax
mov    %rax,0x58(%rsp)
lea    0x1(%r14),%rax
mov    %rax,0x78(%rsp)
lea    -0x1(%r14),%rax
mov    %rax,0x70(%rsp)
mov    %r14d,%r15d
and    $0x3,%r15d
and    $0xfffffffc,%r14d
mov    $0x1,%r12d
jmp    1e6f <poleCompute+0xc6f>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%r12
cmp    0x78(%rsp),%r12
je     1f4d <poleCompute+0xd4d>
mov    0x10(%rsp),%rdi
xor    %esi,%esi
mov    0x58(%rsp),%rdx
call   1070 <memset@plt>
movl   $0x3f800000,0x0(%r13,%r12,4)
80 3f
mov    0x20(%rsp),%rdi
mov    0x38(%rsp),%rsi
mov    0x30(%rsp),%rdx
mov    %r13,%rcx
call   1090 <lubksb@plt>
mov    $0x1,%eax
cmpq   $0x3,0x70(%rsp)
jb     1f05 <poleCompute+0xd05>
xor    %eax,%eax
nop
movss  0x4(%r13,%rax,4),%xmm0
mov    0x8(%rbp,%rax,8),%rcx
movss  %xmm0,(%rcx,%r12,4)
movss  0x8(%r13,%rax,4),%xmm0
mov    0x10(%rbp,%rax,8),%rcx
movss  %xmm0,(%rcx,%r12,4)
movss  0xc(%r13,%rax,4),%xmm0
mov    0x18(%rbp,%rax,8),%rcx
movss  %xmm0,(%rcx,%r12,4)
movss  0x10(%r13,%rax,4),%xmm0
mov    0x20(%rbp,%rax,8),%rcx
movss  %xmm0,(%rcx,%r12,4)
add    $0x4,%rax
cmp    %rax,%r14
jne    1eb0 <poleCompute+0xcb0>
add    $0x1,%rax
test   %r15,%r15
je     1e60 <poleCompute+0xc60>
lea    0x0(,%rax,8),%rcx
add    %rbp,%rcx
lea    0x0(,%rax,4),%rax
add    %r13,%rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
movss  (%rax,%rdx,4),%xmm0
mov    (%rcx,%rdx,8),%rsi
movss  %xmm0,(%rsi,%r12,4)
add    $0x1,%rdx
cmp    %rdx,%r15
jne    1f30 <poleCompute+0xd30>
jmp    1e60 <poleCompute+0xc60>
mov    0x60(%rsp),%r15
mov    %r15,%rdi
mov    %rbp,%rsi
mov    0x68(%rsp),%rdx
mov    0x38(%rsp),%r12
mov    %r12d,%ecx
mov    %r12d,%r8d
mov    %r12d,%r9d
call   1110 <mtm@plt>
mov    $0x1,%edi
mov    %r12d,%esi
call   10b0 <vector@plt>
mov    %rax,%r14
mov    $0x1,%edi
mov    %r12d,%esi
call   10b0 <vector@plt>
mov    %rax,0x10(%rsp)
mov    %r15,%rdi
mov    %r12d,%esi
call   1120 <balanc@plt>
mov    %r15,%rdi
mov    %r12d,%esi
call   10c0 <elmhes@plt>
mov    %r15,%rdi
mov    %r12d,%esi
mov    %r14,%rdx
mov    0x10(%rsp),%rcx
call   1080 <hqr@plt>
test   %r12d,%r12d
jle    21f9 <poleCompute+0xff9>
mov    0x80(%rsp),%rdi
lea    0x1(%rdi),%r15
mov    $0x1,%eax
cmp    $0x8,%r12d
jb     2095 <poleCompute+0xe95>
mov    %edi,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rdx
mov    %rdx,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
test   %rdx,%rdx
je     2352 <poleCompute+0x1152>
movabs $0x3ffffffffffffffc,%rsi
or     $0x2,%rsi
and    %rcx,%rsi
mov    $0x1,%edx
movaps 0x1007(%rip),%xmm0
nopl   0x0(%rax)
movups (%r14,%rdx,4),%xmm1
movups 0x10(%r14,%rdx,4),%xmm2
movups 0x20(%r14,%rdx,4),%xmm3
movups 0x30(%r14,%rdx,4),%xmm4
andps  %xmm0,%xmm1
andps  %xmm0,%xmm2
movups %xmm1,(%r14,%rdx,4)
movups %xmm2,0x10(%r14,%rdx,4)
andps  %xmm0,%xmm3
andps  %xmm0,%xmm4
movups %xmm3,0x20(%r14,%rdx,4)
movups %xmm4,0x30(%r14,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rsi
jne    2020 <poleCompute+0xe20>
test   $0x1,%cl
je     208c <poleCompute+0xe8c>
movups (%r14,%rdx,4),%xmm0
movups 0x10(%r14,%rdx,4),%xmm1
movaps 0xfa5(%rip),%xmm2
andps  %xmm2,%xmm0
andps  %xmm2,%xmm1
movups %xmm0,(%r14,%rdx,4)
movups %xmm1,0x10(%r14,%rdx,4)
cmp    %rax,%rdi
je     20b8 <poleCompute+0xeb8>
or     $0x1,%rax
movaps 0xf84(%rip),%xmm0
nopl   0x0(%rax)
movss  (%r14,%rax,4),%xmm1
andps  %xmm0,%xmm1
movss  %xmm1,(%r14,%rax,4)
add    $0x1,%rax
cmp    %rax,%r15
jne    20a0 <poleCompute+0xea0>
mov    %r14,%rdi
mov    0x60(%rsp),%rsi
mov    %r12d,%edx
call   10d0 <eigsrt@plt>
test   %r12d,%r12d
mov    0x18(%rsp),%rdx
mov    0x88(%rsp),%rcx
jle    220c <poleCompute+0x100c>
lea    -0x1(%r15),%r9
mov    $0x1,%eax
cmp    $0x4,%r9
jb     219c <poleCompute+0xf9c>
lea    0x4(%rcx),%rdi
lea    (%r14,%r15,4),%rsi
cmp    %rsi,%rdi
jae    2112 <poleCompute+0xf12>
lea    (%rcx,%r15,4),%rdi
mov    %r14,%rsi
add    $0x4,%rsi
cmp    %rdi,%rsi
jb     219c <poleCompute+0xf9c>
mov    %r9,%rax
and    $0xfffffffffffffffc,%rax
lea    -0x4(%rax),%rsi
mov    %rsi,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rsi,%rsi
je     2379 <poleCompute+0x1179>
mov    %r8,%rdi
and    $0xfffffffffffffffe,%rdi
mov    $0x1,%esi
movaps 0xeec(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups (%r14,%rsi,4),%xmm1
movaps %xmm0,%xmm2
divps  %xmm1,%xmm2
movups %xmm2,(%rcx,%rsi,4)
movups 0x10(%r14,%rsi,4),%xmm1
movaps %xmm0,%xmm2
divps  %xmm1,%xmm2
movups %xmm2,0x10(%rcx,%rsi,4)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    2150 <poleCompute+0xf50>
test   $0x1,%r8b
je     2193 <poleCompute+0xf93>
movups (%r14,%rsi,4),%xmm0
movaps 0xea4(%rip),%xmm1
divps  %xmm0,%xmm1
movups %xmm1,(%rcx,%rsi,4)
cmp    %rax,%r9
je     220c <poleCompute+0x100c>
or     $0x1,%rax
mov    %rax,%rsi
not    %rsi
test   $0x1,%r15b
jne    21bf <poleCompute+0xfbf>
movss  0xe58(%rip),%xmm0
divss  (%r14,%rax,4),%xmm0
movss  %xmm0,(%rcx,%rax,4)
add    $0x1,%rax
add    %r15,%rsi
je     220c <poleCompute+0x100c>
movss  0xe3c(%rip),%xmm0
nopl   0x0(%rax)
movaps %xmm0,%xmm1
divss  (%r14,%rax,4),%xmm1
movss  %xmm1,(%rcx,%rax,4)
movaps %xmm0,%xmm1
divss  0x4(%r14,%rax,4),%xmm1
movss  %xmm1,0x4(%rcx,%rax,4)
add    $0x2,%rax
cmp    %rax,%r15
jne    21d0 <poleCompute+0xfd0>
jmp    220c <poleCompute+0x100c>
mov    %r14,%rdi
mov    %r15,%rsi
mov    %r12d,%edx
call   10d0 <eigsrt@plt>
mov    0x18(%rsp),%rdx
mov    %rbx,%rdi
mov    $0x1,%esi
mov    $0x1,%ecx
mov    %r12d,%r8d
mov    %rdx,%rbx
call   1040 <free_matrix@plt>
mov    0x48(%rsp),%rdi
mov    $0x1,%esi
mov    %r12d,%edx
mov    $0x1,%ecx
mov    %ebx,%r8d
call   1040 <free_matrix@plt>
mov    0x8(%rsp),%rdi
mov    $0x1,%esi
mov    %ebx,%edx
call   1060 <free_vector@plt>
mov    0x28(%rsp),%rdi
mov    $0x1,%esi
mov    %ebx,%edx
mov    $0x1,%ecx
mov    %ebx,%r8d
call   1040 <free_matrix@plt>
mov    0x90(%rsp),%rdi
mov    $0x1,%esi
mov    %r12d,%edx
mov    $0x1,%ecx
mov    %ebx,%r8d
call   1040 <free_matrix@plt>
mov    0x20(%rsp),%rdi
mov    $0x1,%esi
mov    %r12d,%edx
mov    $0x1,%ecx
mov    %r12d,%r8d
call   1040 <free_matrix@plt>
mov    0x68(%rsp),%rdi
mov    $0x1,%esi
mov    %r12d,%edx
mov    $0x1,%ecx
mov    %r12d,%r8d
call   1040 <free_matrix@plt>
mov    %r13,%rdi
mov    $0x1,%esi
mov    %r12d,%edx
call   1060 <free_vector@plt>
mov    %rbp,%rdi
mov    $0x1,%esi
mov    %r12d,%edx
mov    $0x1,%ecx
mov    %r12d,%r8d
call   1040 <free_matrix@plt>
mov    0x60(%rsp),%rdi
mov    $0x1,%esi
mov    %r12d,%edx
mov    $0x1,%ecx
mov    %r12d,%r8d
call   1040 <free_matrix@plt>
mov    %r14,%rdi
mov    $0x1,%esi
mov    %r12d,%edx
call   1060 <free_vector@plt>
mov    0x10(%rsp),%rdi
mov    $0x1,%esi
mov    %r12d,%edx
call   1060 <free_vector@plt>
mov    0x50(%rsp),%rdi
mov    $0x1,%esi
mov    %ebx,%edx
call   10e0 <free_ivector@plt>
mov    0x30(%rsp),%rdi
mov    $0x1,%esi
mov    %r12d,%edx
call   10e0 <free_ivector@plt>
add    $0x98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    $0x1,%edx
test   $0x1,%cl
jne    2069 <poleCompute+0xe69>
jmp    208c <poleCompute+0xe8c>
mov    $0x1,%eax
test   $0x1,%r15b
jne    165e <poleCompute+0x45e>
jmp    1675 <poleCompute+0x475>
mov    $0x1,%esi
test   $0x1,%r8b
jne    2180 <poleCompute+0xf80>
jmp    2193 <poleCompute+0xf93>

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

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