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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double **dmatrix(int, int, int, int);
double *dvector(int, int);
int /*<<< orphan*/ eigsort(double *, double **, int, int);
int /*<<< orphan*/ errorMsg(char *);
double fabs(double);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, ...);
int /*<<< orphan*/ free_dmatrix(double **, int, int, int, int);
int *ivector(int, int);
int /*<<< orphan*/ jacobi(double **, double **, double *, double **, int);
int /*<<< orphan*/ ldl_dcmp(double **, int, double *, double *, double *, int,
                            int, int *);
int /*<<< orphan*/ ldl_mprove(double **, int, double *, double *, double *,
                              double *, int *);
int /*<<< orphan*/ prodAB(double **, double **, double **, int, int, int);
int /*<<< orphan*/ prodABj(double **, double **, double *, int, int);
int /*<<< orphan*/ sprintf(char *, char *, double, double, ...);
double sqrt(double);
int /*<<< orphan*/ stdout;
int sturm(double **, double **, int, int, double, double, int);
int /*<<< orphan*/ xtAx(double **, double **, double **, int, int);
int subspace(double **K, double **M, int n, int m, double *w, double **V,
             double tol, double shift, int *iter, int *ok, int verbose) {
  double **Kb, **Mb, **Xb, **Qb, *d, *u, *v, km, km_old, error = 1.0,
                                                         w_old = 0.0;
  int i = 0, j = 0, k = 0, modes, disp = 0, *idx;
  char errMsg[512];
  if (m > n) {
    sprintf(errMsg,
            "subspace: Number of eigen-values must be less than the problem "
            "dimension.\n Desired number of eigen-values=%d \n Dimension of "
            "the problem= %d \n",
            m, n);
    errorMsg(errMsg);
    return 32;
  }
  d = dvector(1, n);
  u = dvector(1, n);
  v = dvector(1, n);
  Kb = dmatrix(1, m, 1, m);
  Mb = dmatrix(1, m, 1, m);
  Xb = dmatrix(1, n, 1, m);
  Qb = dmatrix(1, m, 1, m);
  idx = ivector(1, m);
  for (i = 1; i <= m; i++) {
    idx[i] = 0;
    for (j = i; j <= m; j++)
      Kb[i][j] = Kb[j][i] = Mb[i][j] = Mb[j][i] = Qb[i][j] = Qb[j][i] = 0.0;
  }
  for (i = 1; i <= n; i++)
    for (j = 1; j <= m; j++)
      Xb[i][j] = V[i][j] = 0.0;
  modes = (int)((double)(0.5 * m) > (double)(m - 8.0) ? (int)(m / 2.0) : m - 8);
  for (i = 1; i <= n; i++)
    for (j = i; j <= n; j++)
      K[i][j] += shift * M[i][j];
  ldl_dcmp(K, n, u, v, v, 1, 0, ok);
  for (i = 1; i <= n; i++) {
    if (M[i][i] <= 0.0) {
      sprintf(errMsg, " subspace: M[%d][%d] = %e \n", i, i, M[i][i]);
      errorMsg(errMsg);
      return 32;
    }
    d[i] = K[i][i] / M[i][i];
  }
  km_old = 0.0;
  for (k = 1; k <= m; k++) {
    km = d[1];
    for (i = 1; i <= n; i++) {
      if (km_old <= d[i] && d[i] <= km) {
        *ok = 1;
        for (j = 1; j <= k - 1; j++)
          if (i == idx[j])
            *ok = 0;
        if (*ok) {
          km = d[i];
          idx[k] = i;
        }
      }
    }
    if (idx[k] == 0) {
      i = idx[1];
      for (j = 1; j < k; j++)
        if (i < idx[j])
          i = idx[j];
      idx[k] = i + 1;
      km = d[i + 1];
    }
    km_old = km;
  }
  for (k = 1; k <= m; k++) {
    V[idx[k]][k] = 1.0;
    *ok = idx[k] % 6;
    switch (*ok) {
    case 1:
      i = 1;
      j = 2;
      break;
    case 2:
      i = -1;
      j = 1;
      break;
    case 3:
      i = -1;
      j = -2;
      break;
    case 4:
      i = 1;
      j = 2;
      break;
    case 5:
      i = -1;
      j = 1;
      break;
    case 0:
      i = -1;
      j = -2;
      break;
    }
    V[idx[k] + i][k] = 0.2;
    V[idx[k] + j][k] = 0.2;
  }
  *iter = 0;
  do {
    for (k = 1; k <= m; k++) {
      prodABj(M, V, v, n, k);
      ldl_dcmp(K, n, u, v, d, 0, 1, ok);
      if (disp)
        fprintf(stdout, "  RMS matrix error:");
      error = *ok = 1;
      do {
        ldl_mprove(K, n, u, v, d, &error, ok);
        if (disp)
          fprintf(stdout, "%9.2e", error);
      } while (*ok);
      if (disp)
        fprintf(stdout, "\n");
      for (i = 1; i <= n; i++)
        Xb[i][k] = d[i];
    }
    xtAx(K, Xb, Kb, n, m);
    xtAx(M, Xb, Mb, n, m);
    jacobi(Kb, Mb, w, Qb, m);
    prodAB(Xb, Qb, V, n, m, m);
    eigsort(w, V, n, m);
    if (w[modes] == 0.0) {
      sprintf(errMsg, " subspace: Zero frequency found! \n w[%d] = %e \n",
              modes, w[modes]);
      errorMsg(errMsg);
      return 32;
    }
    error = fabs(w[modes] - w_old) / w[modes];
    (*iter)++;
    if (disp)
      fprintf(stdout, " iter = %d  w[%d] = %f error = %e\n", *iter, modes,
              w[modes], error);
    w_old = w[modes];
    if (*iter > 2000) {
      sprintf(errMsg,
              "  subspace: Iteration limit exceeded\n rel. error = %e > %e\n",
              error, tol);
      errorMsg(errMsg);
      return 32;
    }
  } while (error > tol);
  for (k = 1; k <= m; k++) {
    if (w[k] > shift)
      w[k] = w[k] - shift;
    else
      w[k] = shift - w[k];
  }
  if (verbose) {
    fprintf(stdout, " %4d sub-space iterations,   error: %.4e \n", *iter,
            error);
    for (k = 1; k <= m; k++)
      fprintf(stdout, "  mode: %2d\tDoF: %5d\t %9.4lf Hz\n", k, idx[k],
              sqrt(w[k]) /
                  (2.0 * 3.14159265358979323846264338327950288419716939937510));
  }
  *ok = sturm(K, M, n, m, shift, w[modes] + tol, verbose);
  for (i = 1; i <= n; i++)
    for (j = i; j <= n; j++)
      K[i][j] -= shift * M[i][j];
  free_dmatrix(Kb, 1, m, 1, m);
  free_dmatrix(Mb, 1, m, 1, m);
  free_dmatrix(Xb, 1, n, 1, m);
  free_dmatrix(Qb, 1, m, 1, m);
  return 0;
}


x86 assembly (clang, -O0):
<subspace>:
push   %rbp
mov    %rsp,%rbp
sub    $0x2f0,%rsp
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
mov    %ecx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movsd  %xmm0,-0x38(%rbp)
movsd  %xmm1,-0x40(%rbp)
movsd  0x1dc2(%rip),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movl   $0x0,-0x9c(%rbp)
movl   $0x0,-0xa0(%rbp)
movl   $0x0,-0xa4(%rbp)
movl   $0x0,-0xac(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jle    12bc <subspace+0xbc>
lea    -0x2c0(%rbp),%rdi
cvtsi2sdl -0x20(%rbp),%xmm0
cvtsi2sdl -0x1c(%rbp),%xmm1
lea    0x1dbb(%rip),%rsi
mov    $0x2,%al
call   1110 <sprintf@plt>
lea    -0x2c0(%rbp),%rdi
call   10a0 <errorMsg@plt>
movl   $0x20,-0x4(%rbp)
jmp    218e <subspace+0xf8e>
mov    -0x1c(%rbp),%esi
mov    $0x1,%edi
call   10b0 <dvector@plt>
mov    %rax,-0x68(%rbp)
mov    -0x1c(%rbp),%esi
mov    $0x1,%edi
call   10b0 <dvector@plt>
mov    %rax,-0x70(%rbp)
mov    -0x1c(%rbp),%esi
mov    $0x1,%edi
call   10b0 <dvector@plt>
mov    %rax,-0x78(%rbp)
mov    -0x20(%rbp),%esi
mov    -0x20(%rbp),%ecx
mov    $0x1,%edx
mov    %edx,%edi
call   1070 <dmatrix@plt>
mov    %rax,-0x48(%rbp)
mov    -0x20(%rbp),%esi
mov    -0x20(%rbp),%ecx
mov    $0x1,%edx
mov    %edx,%edi
call   1070 <dmatrix@plt>
mov    %rax,-0x50(%rbp)
mov    -0x1c(%rbp),%esi
mov    -0x20(%rbp),%ecx
mov    $0x1,%edx
mov    %edx,%edi
call   1070 <dmatrix@plt>
mov    %rax,-0x58(%rbp)
mov    -0x20(%rbp),%esi
mov    -0x20(%rbp),%ecx
mov    $0x1,%edx
mov    %edx,%edi
call   1070 <dmatrix@plt>
mov    %rax,-0x60(%rbp)
mov    -0x20(%rbp),%esi
mov    $0x1,%edi
call   10e0 <ivector@plt>
mov    %rax,-0xb8(%rbp)
movl   $0x1,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jg     1485 <subspace+0x285>
mov    -0xb8(%rbp),%rax
movslq -0x9c(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x9c(%rbp),%eax
mov    %eax,-0xa0(%rbp)
mov    -0xa0(%rbp),%eax
cmp    -0x20(%rbp),%eax
jg     146c <subspace+0x26c>
mov    -0x60(%rbp),%rax
movslq -0xa0(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x9c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x60(%rbp),%rax
movslq -0x9c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xa0(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%rax
movslq -0xa0(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x9c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%rax
movslq -0x9c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xa0(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%rax
movslq -0xa0(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x9c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%rax
movslq -0x9c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xa0(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa0(%rbp)
jmp    1395 <subspace+0x195>
jmp    1471 <subspace+0x271>
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    1365 <subspace+0x165>
movl   $0x1,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1520 <subspace+0x320>
movl   $0x1,-0xa0(%rbp)
mov    -0xa0(%rbp),%eax
cmp    -0x20(%rbp),%eax
jg     1507 <subspace+0x307>
mov    -0x30(%rbp),%rax
movslq -0x9c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xa0(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x58(%rbp),%rax
movslq -0x9c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xa0(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa0(%rbp)
jmp    14a8 <subspace+0x2a8>
jmp    150c <subspace+0x30c>
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    148f <subspace+0x28f>
cvtsi2sdl -0x20(%rbp),%xmm1
movsd  0x1ae3(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsi2sdl -0x20(%rbp),%xmm1
movsd  0x1aca(%rip),%xmm2
subsd  %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jbe    156c <subspace+0x36c>
cvtsi2sdl -0x20(%rbp),%xmm0
movsd  0x1abf(%rip),%xmm1
divsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x2c4(%rbp)
jmp    1578 <subspace+0x378>
mov    -0x20(%rbp),%eax
sub    $0x8,%eax
mov    %eax,-0x2c4(%rbp)
mov    -0x2c4(%rbp),%eax
mov    %eax,-0xa8(%rbp)
movl   $0x1,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     162d <subspace+0x42d>
mov    -0x9c(%rbp),%eax
mov    %eax,-0xa0(%rbp)
mov    -0xa0(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1614 <subspace+0x414>
movsd  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x9c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xa0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x9c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xa0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa0(%rbp)
jmp    15a9 <subspace+0x3a9>
jmp    1619 <subspace+0x419>
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    158e <subspace+0x38e>
mov    -0x10(%rbp),%rdi
mov    -0x1c(%rbp),%esi
mov    -0x70(%rbp),%rdx
mov    -0x78(%rbp),%rcx
mov    -0x78(%rbp),%r8
mov    0x18(%rbp),%rax
mov    $0x1,%r9d
xor    %r10d,%r10d
movl   $0x0,(%rsp)
mov    %rax,0x8(%rsp)
call   1090 <ldl_dcmp@plt>
movl   $0x1,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     174d <subspace+0x54d>
mov    -0x18(%rbp),%rax
movslq -0x9c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x9c(%rbp),%rcx
xorps  %xmm0,%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jb     16f3 <subspace+0x4f3>
lea    -0x2c0(%rbp),%rdi
cvtsi2sdl -0x9c(%rbp),%xmm0
ff
cvtsi2sdl -0x9c(%rbp),%xmm1
ff
mov    -0x18(%rbp),%rax
movslq -0x9c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x9c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
lea    0x1a12(%rip),%rsi
mov    $0x3,%al
call   1110 <sprintf@plt>
lea    -0x2c0(%rbp),%rdi
call   10a0 <errorMsg@plt>
movl   $0x20,-0x4(%rbp)
jmp    218e <subspace+0xf8e>
mov    -0x10(%rbp),%rax
movslq -0x9c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x9c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x9c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x9c(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x9c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    1668 <subspace+0x468>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movl   $0x1,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
cmp    -0x20(%rbp),%eax
jg     1981 <subspace+0x781>
mov    -0x68(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x80(%rbp)
movl   $0x1,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     189b <subspace+0x69b>
movsd  -0x88(%rbp),%xmm1
ff
mov    -0x68(%rbp),%rax
movslq -0x9c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jb     1882 <subspace+0x682>
mov    -0x68(%rbp),%rax
movslq -0x9c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x80(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     1882 <subspace+0x682>
mov    0x18(%rbp),%rax
movl   $0x1,(%rax)
movl   $0x1,-0xa0(%rbp)
mov    -0xa0(%rbp),%eax
mov    -0xa4(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1844 <subspace+0x644>
mov    -0x9c(%rbp),%eax
mov    -0xb8(%rbp),%rcx
movslq -0xa0(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jne    182b <subspace+0x62b>
mov    0x18(%rbp),%rax
movl   $0x0,(%rax)
jmp    1830 <subspace+0x630>
mov    -0xa0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa0(%rbp)
jmp    17ed <subspace+0x5ed>
mov    0x18(%rbp),%rax
cmpl   $0x0,(%rax)
je     187d <subspace+0x67d>
mov    -0x68(%rbp),%rax
movslq -0x9c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x9c(%rbp),%edx
mov    -0xb8(%rbp),%rax
movslq -0xa4(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1882 <subspace+0x682>
jmp    1887 <subspace+0x687>
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    1789 <subspace+0x589>
mov    -0xb8(%rbp),%rax
movslq -0xa4(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    1960 <subspace+0x760>
mov    -0xb8(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x9c(%rbp)
movl   $0x1,-0xa0(%rbp)
mov    -0xa0(%rbp),%eax
cmp    -0xa4(%rbp),%eax
jge    192c <subspace+0x72c>
mov    -0x9c(%rbp),%eax
mov    -0xb8(%rbp),%rcx
movslq -0xa0(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1913 <subspace+0x713>
mov    -0xb8(%rbp),%rax
movslq -0xa0(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x9c(%rbp)
jmp    1918 <subspace+0x718>
mov    -0xa0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa0(%rbp)
jmp    18cd <subspace+0x6cd>
mov    -0x9c(%rbp),%edx
add    $0x1,%edx
mov    -0xb8(%rbp),%rax
movslq -0xa4(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x68(%rbp),%rax
mov    -0x9c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    1762 <subspace+0x562>
movl   $0x1,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
cmp    -0x20(%rbp),%eax
jg     1b38 <subspace+0x938>
mov    -0x30(%rbp),%rax
mov    -0xb8(%rbp),%rdx
movslq -0xa4(%rbp),%rcx
movslq (%rdx,%rcx,4),%rdx
mov    (%rax,%rdx,8),%rax
movabs $0x3ff0000000000000,%rdx
mov    %rdx,(%rax,%rcx,8)
mov    -0xb8(%rbp),%rax
movslq -0xa4(%rbp),%rcx
movslq (%rax,%rcx,4),%rax
mov    %eax,%ecx
imul   $0x2aaaaaab,%rax,%rdx
mov    %rdx,%rax
shr    $0x3f,%rax
shr    $0x20,%rdx
add    %eax,%edx
add    %edx,%edx
mov    %edx,%eax
lea    (%rax,%rax,2),%eax
sub    %eax,%ecx
mov    0x18(%rbp),%rax
mov    %ecx,(%rax)
mov    0x18(%rbp),%rax
mov    (%rax),%eax
mov    %rax,-0x2d0(%rbp)
sub    $0x5,%rax
ja     1ab8 <subspace+0x8b8>
mov    -0x2d0(%rbp),%rax
lea    0x1622(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movl   $0x1,-0x9c(%rbp)
movl   $0x2,-0xa0(%rbp)
jmp    1ab8 <subspace+0x8b8>
movl   $0xffffffff,-0x9c(%rbp)
ff ff ff
movl   $0x1,-0xa0(%rbp)
jmp    1ab8 <subspace+0x8b8>
movl   $0xffffffff,-0x9c(%rbp)
ff ff ff
movl   $0xfffffffe,-0xa0(%rbp)
ff ff ff
jmp    1ab8 <subspace+0x8b8>
movl   $0x1,-0x9c(%rbp)
movl   $0x2,-0xa0(%rbp)
jmp    1ab8 <subspace+0x8b8>
movl   $0xffffffff,-0x9c(%rbp)
ff ff ff
movl   $0x1,-0xa0(%rbp)
jmp    1ab8 <subspace+0x8b8>
movl   $0xffffffff,-0x9c(%rbp)
ff ff ff
movl   $0xfffffffe,-0xa0(%rbp)
ff ff ff
mov    -0x30(%rbp),%rax
mov    -0xb8(%rbp),%rcx
movslq -0xa4(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
add    -0x9c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xa4(%rbp),%rcx
movsd  0x153f(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
mov    -0xb8(%rbp),%rcx
movslq -0xa4(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
add    -0xa0(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xa4(%rbp),%rcx
movsd  0x1509(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    198b <subspace+0x78b>
mov    0x10(%rbp),%rax
movl   $0x0,(%rax)
movl   $0x1,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
cmp    -0x20(%rbp),%eax
jg     1cd9 <subspace+0xad9>
mov    -0x18(%rbp),%rdi
mov    -0x30(%rbp),%rsi
mov    -0x78(%rbp),%rdx
mov    -0x1c(%rbp),%ecx
mov    -0xa4(%rbp),%r8d
call   1030 <prodABj@plt>
mov    -0x10(%rbp),%rdi
mov    -0x1c(%rbp),%esi
mov    -0x70(%rbp),%rdx
mov    -0x78(%rbp),%rcx
mov    -0x68(%rbp),%r8
mov    0x18(%rbp),%rax
xor    %r9d,%r9d
movl   $0x1,(%rsp)
mov    %rax,0x8(%rsp)
call   1090 <ldl_dcmp@plt>
cmpl   $0x0,-0xac(%rbp)
je     1bc5 <subspace+0x9c5>
mov    0x342b(%rip),%rax
mov    (%rax),%edi
lea    0x1544(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    0x18(%rbp),%rax
movl   $0x1,(%rax)
movsd  0x1429(%rip),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x10(%rbp),%rdi
mov    -0x1c(%rbp),%esi
mov    -0x70(%rbp),%rdx
mov    -0x78(%rbp),%rcx
mov    -0x68(%rbp),%r8
mov    0x18(%rbp),%rax
lea    -0x90(%rbp),%r9
mov    %rax,(%rsp)
call   1060 <ldl_mprove@plt>
cmpl   $0x0,-0xac(%rbp)
je     1c32 <subspace+0xa32>
mov    0x33c6(%rip),%rax
mov    (%rax),%edi
movsd  -0x90(%rbp),%xmm0
ff
lea    0x14eb(%rip),%rsi
mov    $0x1,%al
call   1080 <fprintf@plt>
jmp    1c37 <subspace+0xa37>
mov    0x18(%rbp),%rax
cmpl   $0x0,(%rax)
jne    1bdf <subspace+0x9df>
cmpl   $0x0,-0xac(%rbp)
je     1c68 <subspace+0xa68>
mov    0x3388(%rip),%rax
mov    (%rax),%edi
lea    0x1483(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
movl   $0x1,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1cc0 <subspace+0xac0>
mov    -0x68(%rbp),%rax
movslq -0x9c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x9c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xa4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    1c72 <subspace+0xa72>
jmp    1cc5 <subspace+0xac5>
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    1b4c <subspace+0x94c>
mov    -0x10(%rbp),%rdi
mov    -0x58(%rbp),%rsi
mov    -0x48(%rbp),%rdx
mov    -0x1c(%rbp),%ecx
mov    -0x20(%rbp),%r8d
call   1050 <xtAx@plt>
mov    -0x18(%rbp),%rdi
mov    -0x58(%rbp),%rsi
mov    -0x50(%rbp),%rdx
mov    -0x1c(%rbp),%ecx
mov    -0x20(%rbp),%r8d
call   1050 <xtAx@plt>
mov    -0x48(%rbp),%rdi
mov    -0x50(%rbp),%rsi
mov    -0x28(%rbp),%rdx
mov    -0x60(%rbp),%rcx
mov    -0x20(%rbp),%r8d
call   1040 <jacobi@plt>
mov    -0x58(%rbp),%rdi
mov    -0x60(%rbp),%rsi
mov    -0x30(%rbp),%rdx
mov    -0x1c(%rbp),%ecx
mov    -0x20(%rbp),%r8d
mov    -0x20(%rbp),%r9d
call   10d0 <prodAB@plt>
mov    -0x28(%rbp),%rdi
mov    -0x30(%rbp),%rsi
mov    -0x1c(%rbp),%edx
mov    -0x20(%rbp),%ecx
call   1120 <eigsort@plt>
mov    -0x28(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1db9 <subspace+0xbb9>
jp     1db9 <subspace+0xbb9>
lea    -0x2c0(%rbp),%rdi
cvtsi2sdl -0xa8(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
lea    0x1382(%rip),%rsi
mov    $0x2,%al
call   1110 <sprintf@plt>
lea    -0x2c0(%rbp),%rdi
call   10a0 <errorMsg@plt>
movl   $0x20,-0x4(%rbp)
jmp    218e <subspace+0xf8e>
mov    -0x28(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x98(%rbp),%xmm0
ff
movaps 0x1258(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movslq -0xa8(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    0x10(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
cmpl   $0x0,-0xac(%rbp)
je     1e47 <subspace+0xc47>
mov    0x31cd(%rip),%rax
mov    (%rax),%edi
mov    0x10(%rbp),%rax
mov    (%rax),%edx
mov    -0xa8(%rbp),%ecx
mov    -0x28(%rbp),%rax
movslq -0xa8(%rbp),%rsi
movsd  (%rax,%rsi,8),%xmm0
movsd  -0x90(%rbp),%xmm1
ff
lea    0x130c(%rip),%rsi
mov    $0x2,%al
call   1080 <fprintf@plt>
mov    -0x28(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    0x10(%rbp),%rax
cmpl   $0x7d0,(%rax)
jle    1ea9 <subspace+0xca9>
lea    -0x2c0(%rbp),%rdi
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0x38(%rbp),%xmm1
lea    0x12e5(%rip),%rsi
mov    $0x2,%al
call   1110 <sprintf@plt>
lea    -0x2c0(%rbp),%rdi
call   10a0 <errorMsg@plt>
movl   $0x20,-0x4(%rbp)
jmp    218e <subspace+0xf8e>
jmp    1eae <subspace+0xcae>
movsd  -0x90(%rbp),%xmm0
ff
ucomisd -0x38(%rbp),%xmm0
ja     1b42 <subspace+0x942>
movl   $0x1,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
cmp    -0x20(%rbp),%eax
jg     1f5d <subspace+0xd5d>
mov    -0x28(%rbp),%rax
movslq -0xa4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0x40(%rbp),%xmm0
jbe    1f1f <subspace+0xd1f>
mov    -0x28(%rbp),%rax
movslq -0xa4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x40(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0xa4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1f44 <subspace+0xd44>
movsd  -0x40(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0xa4(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0xa4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1f49 <subspace+0xd49>
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    1ecb <subspace+0xccb>
cmpl   $0x0,0x20(%rbp)
je     2031 <subspace+0xe31>
mov    0x3072(%rip),%rax
mov    (%rax),%edi
mov    0x10(%rbp),%rax
mov    (%rax),%edx
movsd  -0x90(%rbp),%xmm0
ff
lea    0x1226(%rip),%rsi
mov    $0x1,%al
call   1080 <fprintf@plt>
movl   $0x1,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
cmp    -0x20(%rbp),%eax
jg     202c <subspace+0xe2c>
mov    0x3034(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x2dc(%rbp)
mov    -0xa4(%rbp),%eax
mov    %eax,-0x2d8(%rbp)
mov    -0xb8(%rbp),%rax
movslq -0xa4(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x2d4(%rbp)
mov    -0x28(%rbp),%rax
movslq -0xa4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1100 <sqrt@plt>
mov    -0x2dc(%rbp),%edi
mov    -0x2d8(%rbp),%edx
mov    -0x2d4(%rbp),%ecx
movsd  0x101a(%rip),%xmm1
divsd  %xmm1,%xmm0
lea    0x11c5(%rip),%rsi
mov    $0x1,%al
call   1080 <fprintf@plt>
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    1f96 <subspace+0xd96>
jmp    2031 <subspace+0xe31>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x1c(%rbp),%edx
mov    -0x20(%rbp),%ecx
movsd  -0x40(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0xa8(%rbp),%r8
movsd  (%rax,%r8,8),%xmm1
addsd  -0x38(%rbp),%xmm1
mov    0x20(%rbp),%r8d
call   10c0 <sturm@plt>
mov    %eax,%ecx
mov    0x18(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     212b <subspace+0xf2b>
mov    -0x9c(%rbp),%eax
mov    %eax,-0xa0(%rbp)
mov    -0xa0(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     2112 <subspace+0xf12>
movsd  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x9c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xa0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x9c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xa0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa0(%rbp)
jmp    2090 <subspace+0xe90>
jmp    2117 <subspace+0xf17>
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    2075 <subspace+0xe75>
mov    -0x48(%rbp),%rdi
mov    -0x20(%rbp),%edx
mov    -0x20(%rbp),%r8d
mov    $0x1,%ecx
mov    %ecx,%esi
call   10f0 <free_dmatrix@plt>
mov    -0x50(%rbp),%rdi
mov    -0x20(%rbp),%edx
mov    -0x20(%rbp),%r8d
mov    $0x1,%ecx
mov    %ecx,%esi
call   10f0 <free_dmatrix@plt>
mov    -0x58(%rbp),%rdi
mov    -0x1c(%rbp),%edx
mov    -0x20(%rbp),%r8d
mov    $0x1,%ecx
mov    %ecx,%esi
call   10f0 <free_dmatrix@plt>
mov    -0x60(%rbp),%rdi
mov    -0x20(%rbp),%edx
mov    -0x20(%rbp),%r8d
mov    $0x1,%ecx
mov    %ecx,%esi
call   10f0 <free_dmatrix@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x2f0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<subspace>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x2e8,%rsp
mov    %ecx,%ebx
mov    %edx,%r14d
movabs $0x3ff0000000000000,%rax
mov    %rax,0x88(%rsp)
cmp    %edx,%ecx
jle    1247 <subspace+0x47>
xorps  %xmm0,%xmm0
cvtsi2sd %ebx,%xmm0
xorps  %xmm1,%xmm1
cvtsi2sd %r14d,%xmm1
lea    0x1dfe(%rip),%rsi
jmp    222c <subspace+0x102c>
mov    %rdi,%rbp
mov    %r9,0x28(%rsp)
mov    %r8,0x50(%rsp)
movsd  %xmm0,0x70(%rsp)
mov    %rsi,0x40(%rsp)
movaps %xmm1,0x90(%rsp)
mov    $0x1,%edi
mov    %r14d,%esi
call   10b0 <dvector@plt>
mov    %rax,%r15
mov    $0x1,%edi
mov    %r14d,%esi
call   10b0 <dvector@plt>
mov    %rax,0x60(%rsp)
mov    $0x1,%edi
mov    %r14d,%esi
call   10b0 <dvector@plt>
mov    %rax,0x68(%rsp)
mov    $0x1,%edi
mov    %ebx,%esi
mov    $0x1,%edx
mov    %ebx,%ecx
call   1070 <dmatrix@plt>
mov    %rax,%r12
mov    $0x1,%edi
mov    %ebx,%esi
mov    $0x1,%edx
mov    %ebx,%ecx
call   1070 <dmatrix@plt>
mov    %rax,0x78(%rsp)
mov    $0x1,%edi
mov    %r14,(%rsp)
mov    %r14d,%esi
mov    $0x1,%edx
mov    %ebx,%ecx
call   1070 <dmatrix@plt>
mov    %rax,0x30(%rsp)
mov    $0x1,%edi
mov    %ebx,%esi
mov    $0x1,%edx
mov    %ebx,%ecx
call   1070 <dmatrix@plt>
mov    %rax,%r14
mov    $0x1,%edi
mov    %ebx,%esi
call   10e0 <ivector@plt>
mov    %rax,0x10(%rsp)
test   %ebx,%ebx
mov    %rbx,0x18(%rsp)
mov    %rbp,0x20(%rsp)
mov    %r12,0x80(%rsp)
mov    %r14,0xb0(%rsp)
jle    13ea <subspace+0x1ea>
lea    0x1(%rbx),%r13d
mov    $0x1,%eax
mov    (%rsp),%r10
movapd 0x90(%rsp),%xmm6
mov    0x78(%rsp),%r11
jmp    135d <subspace+0x15d>
nopl   0x0(%rax)
add    $0x1,%rax
cmp    %r13,%rax
je     13fa <subspace+0x1fa>
mov    0x10(%rsp),%rcx
movl   $0x0,(%rcx,%rax,4)
mov    (%r14,%rax,8),%r8
mov    (%r11,%rax,8),%r9
mov    (%r12,%rax,8),%rsi
movq   $0x0,(%r8,%rax,8)
movq   $0x0,(%r9,%rax,8)
movq   $0x0,(%rsi,%rax,8)
lea    0x1(%rax),%rdi
cmp    %r13,%rdi
je     1350 <subspace+0x150>
cs nopw 0x0(%rax,%rax,1)
mov    (%r14,%rdi,8),%rbx
mov    (%r11,%rdi,8),%rcx
mov    (%r12,%rdi,8),%rdx
movq   $0x0,(%rbx,%rax,8)
movq   $0x0,(%r8,%rdi,8)
movq   $0x0,(%rcx,%rax,8)
movq   $0x0,(%r9,%rdi,8)
movq   $0x0,(%rdx,%rax,8)
movq   $0x0,(%rsi,%rdi,8)
add    $0x1,%rdi
cmp    %rdi,%r13
jne    13a0 <subspace+0x1a0>
jmp    1350 <subspace+0x150>
xor    %r13d,%r13d
mov    (%rsp),%r10
movapd 0x90(%rsp),%xmm6
test   %r10d,%r10d
mov    0x60(%rsp),%rdx
jle    1627 <subspace+0x427>
mov    0x18(%rsp),%rax
add    $0x1,%eax
mov    (%rsp),%rcx
lea    0x1(%rcx),%r12d
lea    -0x1(%rax),%rbp
lea    -0x5(%rax),%r8
mov    %r8,%r11
shr    $0x2,%r11
add    $0x1,%r11
mov    %rbp,%r10
and    $0xfffffffffffffffc,%r10
lea    0x1(%r10),%rcx
mov    %rcx,0x8(%rsp)
mov    %r11d,%r14d
and    $0x3,%r14d
and    $0xfffffffffffffffc,%r11
mov    $0x1,%r9d
xorps  %xmm0,%xmm0
jmp    1478 <subspace+0x278>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    $0x1,%r13d
add    $0x1,%r9
cmp    %r12,%r9
mov    0x60(%rsp),%rdx
je     1627 <subspace+0x427>
cmpl   $0x0,0x18(%rsp)
jle    1460 <subspace+0x260>
mov    0x28(%rsp),%rcx
mov    (%rcx,%r9,8),%rdi
mov    0x30(%rsp),%rcx
mov    (%rcx,%r9,8),%rdx
mov    $0x1,%ecx
cmp    $0x4,%rbp
jb     1580 <subspace+0x380>
lea    0x8(%rdi),%rsi
lea    (%rdx,%rax,8),%rbx
cmp    %rbx,%rsi
jae    14be <subspace+0x2be>
lea    (%rdi,%rax,8),%rsi
lea    0x8(%rdx),%rbx
cmp    %rsi,%rbx
jb     1580 <subspace+0x380>
cmp    $0xc,%r8
jae    14c8 <subspace+0x2c8>
xor    %ecx,%ecx
jmp    152a <subspace+0x32a>
mov    %r11,%rsi
xor    %ecx,%ecx
nopl   (%rax)
movups %xmm0,0x8(%rdi,%rcx,8)
movups %xmm0,0x18(%rdi,%rcx,8)
movups %xmm0,0x8(%rdx,%rcx,8)
movups %xmm0,0x18(%rdx,%rcx,8)
movups %xmm0,0x28(%rdi,%rcx,8)
movups %xmm0,0x38(%rdi,%rcx,8)
movups %xmm0,0x28(%rdx,%rcx,8)
movups %xmm0,0x38(%rdx,%rcx,8)
movups %xmm0,0x48(%rdi,%rcx,8)
movups %xmm0,0x58(%rdi,%rcx,8)
movups %xmm0,0x48(%rdx,%rcx,8)
movups %xmm0,0x58(%rdx,%rcx,8)
movups %xmm0,0x68(%rdi,%rcx,8)
movups %xmm0,0x78(%rdi,%rcx,8)
movups %xmm0,0x68(%rdx,%rcx,8)
movups %xmm0,0x78(%rdx,%rcx,8)
add    $0x10,%rcx
add    $0xfffffffffffffffc,%rsi
jne    14d0 <subspace+0x2d0>
test   %r14,%r14
je     1568 <subspace+0x368>
mov    %r14,%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    0x0(,%rcx,8),%rbx
or     $0x8,%rbx
movups %xmm0,(%rdi,%rbx,1)
movups %xmm0,0x10(%rdi,%rbx,1)
movups %xmm0,(%rdx,%rbx,1)
movups %xmm0,0x10(%rdx,%rbx,1)
add    $0x4,%rcx
add    $0xffffffffffffffff,%rsi
jne    1540 <subspace+0x340>
mov    0x8(%rsp),%rcx
mov    %eax,%r13d
cmp    %r10,%rbp
je     1466 <subspace+0x266>
nopl   0x0(%rax)
mov    %eax,%ebx
sub    %ecx,%ebx
mov    %rcx,%rsi
not    %rsi
add    %rax,%rsi
and    $0x3,%rbx
je     15ba <subspace+0x3ba>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movq   $0x0,(%rdi,%rcx,8)
movq   $0x0,(%rdx,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rbx
jne    15a0 <subspace+0x3a0>
mov    %eax,%r13d
cmp    $0x3,%rsi
jb     1466 <subspace+0x266>
nopw   0x0(%rax,%rax,1)
movq   $0x0,(%rdi,%rcx,8)
movq   $0x0,(%rdx,%rcx,8)
movq   $0x0,0x8(%rdi,%rcx,8)
movq   $0x0,0x8(%rdx,%rcx,8)
movq   $0x0,0x10(%rdi,%rcx,8)
movq   $0x0,0x10(%rdx,%rcx,8)
movq   $0x0,0x18(%rdi,%rcx,8)
movq   $0x0,0x18(%rdx,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rax
jne    15d0 <subspace+0x3d0>
mov    %eax,%r13d
jmp    1466 <subspace+0x266>
mov    0x18(%rsp),%rax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  0x19c5(%rip),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x19c1(%rip),%xmm0
add    $0xfffffff8,%eax
ucomisd %xmm0,%xmm1
cvttsd2si %xmm1,%ecx
cmovbe %eax,%ecx
mov    %ecx,0x4c(%rsp)
mov    (%rsp),%rsi
test   %esi,%esi
jle    1912 <subspace+0x712>
lea    0x1(%rsi),%r13d
mov    %esi,%r9d
lea    0x1(%r9),%r11
movapd %xmm6,%xmm0
unpcklpd %xmm6,%xmm0
mov    %r9,%rax
not    %rax
mov    %rax,0x8(%rsp)
add    $0xfffffffffffffffc,%r9
mov    $0x1,%ebx
mov    $0x7,%r10d
xor    %r12d,%r12d
mov    0x40(%rsp),%r14
mov    0x20(%rsp),%rbp
jmp    16c9 <subspace+0x4c9>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbx
add    $0x1,%r12
add    $0x1,%r10
add    $0xffffffffffffffff,%r9
cmp    %r11,%rbx
je     1897 <subspace+0x697>
mov    %r12,%rdx
not    %rdx
lea    (%rdx,%r11,1),%rcx
mov    (%r14,%rbx,8),%rax
mov    0x0(%rbp,%rbx,8),%rdi
mov    %rbx,%rsi
cmp    $0x4,%rcx
jb     1820 <subspace+0x620>
lea    (%rdi,%rbx,8),%r8
lea    (%rax,%r11,8),%rsi
cmp    %rsi,%r8
jae    170f <subspace+0x50f>
lea    (%rdi,%r11,8),%r8
lea    (%rax,%rbx,8),%rbp
mov    %rbx,%rsi
cmp    %r8,%rbp
mov    0x20(%rsp),%rbp
jb     1820 <subspace+0x620>
add    %r11,%rdx
add    $0xfffffffffffffffc,%rdx
mov    %rdx,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
cmp    $0x4,%rdx
mov    %rsi,0x38(%rsp)
jae    1733 <subspace+0x533>
xor    %edx,%edx
jmp    17c8 <subspace+0x5c8>
mov    %r9,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
and    $0xfffffffffffffffe,%rsi
lea    (%rdi,%r10,8),%r8
lea    (%rax,%r10,8),%rbp
xor    %edx,%edx
nopl   0x0(%rax)
movupd -0x30(%rbp,%rdx,8),%xmm1
movupd -0x20(%rbp,%rdx,8),%xmm2
mulpd  %xmm0,%xmm1
movupd -0x30(%r8,%rdx,8),%xmm3
addpd  %xmm1,%xmm3
movupd -0x20(%r8,%rdx,8),%xmm1
movupd -0x10(%r8,%rdx,8),%xmm4
movupd (%r8,%rdx,8),%xmm5
mulpd  %xmm0,%xmm2
addpd  %xmm1,%xmm2
movupd %xmm3,-0x30(%r8,%rdx,8)
movupd %xmm2,-0x20(%r8,%rdx,8)
movupd -0x10(%rbp,%rdx,8),%xmm1
movupd 0x0(%rbp,%rdx,8),%xmm2
mulpd  %xmm0,%xmm1
addpd  %xmm4,%xmm1
mulpd  %xmm0,%xmm2
addpd  %xmm5,%xmm2
movupd %xmm1,-0x10(%r8,%rdx,8)
movupd %xmm2,(%r8,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rsi
jne    1750 <subspace+0x550>
mov    %rcx,%rsi
and    $0xfffffffffffffffc,%rsi
testb  $0x1,0x38(%rsp)
je     180a <subspace+0x60a>
add    %rbx,%rdx
movupd (%rax,%rdx,8),%xmm1
movupd 0x10(%rax,%rdx,8),%xmm2
movupd (%rdi,%rdx,8),%xmm3
movupd 0x10(%rdi,%rdx,8),%xmm4
mulpd  %xmm0,%xmm1
addpd  %xmm3,%xmm1
mulpd  %xmm0,%xmm2
addpd  %xmm4,%xmm2
movupd %xmm1,(%rdi,%rdx,8)
movupd %xmm2,0x10(%rdi,%rdx,8)
cmp    %rsi,%rcx
mov    0x20(%rsp),%rbp
mov    0x68(%rsp),%rcx
je     16b0 <subspace+0x4b0>
add    %rbx,%rsi
mov    %r11d,%ecx
sub    %esi,%ecx
mov    %rsi,%rdx
test   $0x1,%cl
je     1844 <subspace+0x644>
movsd  (%rax,%rsi,8),%xmm1
mulsd  %xmm6,%xmm1
addsd  (%rdi,%rsi,8),%xmm1
movsd  %xmm1,(%rdi,%rsi,8)
lea    0x1(%rsi),%rdx
not    %rsi
cmp    0x8(%rsp),%rsi
mov    0x68(%rsp),%rcx
je     16b0 <subspace+0x4b0>
nopw   0x0(%rax,%rax,1)
movsd  (%rax,%rdx,8),%xmm1
mulsd  %xmm6,%xmm1
addsd  (%rdi,%rdx,8),%xmm1
movsd  %xmm1,(%rdi,%rdx,8)
movsd  0x8(%rax,%rdx,8),%xmm1
mulsd  %xmm6,%xmm1
addsd  0x8(%rdi,%rdx,8),%xmm1
movsd  %xmm1,0x8(%rdi,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%r11
jne    1860 <subspace+0x660>
jmp    16b0 <subspace+0x4b0>
mov    %rbp,%rdi
mov    (%rsp),%rbx
mov    %ebx,%esi
mov    0x60(%rsp),%rdx
mov    %rcx,%r8
mov    $0x1,%r9d
push   0x328(%rsp)
push   $0x0
call   1090 <ldl_dcmp@plt>
mov    %rbx,%rcx
add    $0x10,%rsp
test   %ecx,%ecx
mov    0x10(%rsp),%r12
jle    1946 <subspace+0x746>
lea    0x1(%rcx),%esi
mov    $0x1,%eax
xorpd  %xmm0,%xmm0
mov    0x28(%rsp),%r10
nopl   (%rax)
mov    (%r14,%rax,8),%rdx
movsd  (%rdx,%rax,8),%xmm2
ucomisd %xmm2,%xmm0
jae    2277 <subspace+0x1077>
mov    0x0(%rbp,%rax,8),%rdx
movsd  (%rdx,%rax,8),%xmm1
divsd  %xmm2,%xmm1
movsd  %xmm1,(%r15,%rax,8)
add    $0x1,%rax
cmp    %rax,%rsi
jne    18e0 <subspace+0x6e0>
jmp    194b <subspace+0x74b>
mov    0x20(%rsp),%rdi
mov    0x68(%rsp),%rcx
mov    %rcx,%r8
mov    $0x1,%r9d
push   0x328(%rsp)
push   $0x0
call   1090 <ldl_dcmp@plt>
mov    0x10(%rsp),%rcx
add    $0x10,%rsp
mov    0x40(%rsp),%r14
mov    0x10(%rsp),%r12
mov    0x28(%rsp),%r10
mov    0x18(%rsp),%rax
test   %eax,%eax
jle    1d71 <subspace+0xb71>
movsd  0x8(%r15),%xmm0
lea    0x1(%rcx),%r9d
lea    0x1(%rax),%esi
xorpd  %xmm1,%xmm1
mov    $0xffffffff,%r11d
mov    $0x1,%r10d
mov    $0xfffffffffffffff7,%rcx
xor    %eax,%eax
xor    %edx,%edx
mov    %rdx,0x38(%rsp)
mov    %rsi,0x58(%rsp)
jmp    19ca <subspace+0x7ca>
mov    0x10(%rsp),%r12
mov    0x8(%rsp),%rcx
lea    0x1(%rbp),%edx
mov    %edx,(%r12,%r10,4)
movslq %ebp,%rdx
movsd  0x8(%r15,%rdx,8),%xmm2
add    $0x1,%r10
add    $0x1,%r11d
addq   $0x1,0x38(%rsp)
add    $0xffffffffffffffff,%rax
add    $0x1,%rcx
movapd %xmm2,%xmm1
cmp    %rsi,%r10
je     1cba <subspace+0xaba>
mov    %r11d,%r8d
add    $0x2,%r8
cmpl   $0x0,(%rsp)
mov    %rcx,0x8(%rsp)
jle    1ad0 <subspace+0x8d0>
mov    $0x1,%ecx
movapd %xmm0,%xmm2
mov    0x328(%rsp),%rsi
jmp    1a15 <subspace+0x815>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %ecx,(%r12,%r10,4)
movapd %xmm3,%xmm2
add    $0x1,%rcx
cmp    %r9,%rcx
je     1ab0 <subspace+0x8b0>
movsd  (%r15,%rcx,8),%xmm3
ucomisd %xmm1,%xmm3
jb     1a08 <subspace+0x808>
ucomisd %xmm3,%xmm2
jb     1a08 <subspace+0x808>
movl   $0x1,(%rsi)
mov    $0x1,%r13d
cmp    $0x2,%r10
jb     1a00 <subspace+0x800>
mov    $0x1,%edi
xor    %edx,%edx
add    $0x1,%rdi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    -0x4(%r12,%rdi,4),%ebx
cmp    %rbx,%rcx
je     1a70 <subspace+0x870>
lea    (%rax,%rdi,1),%rbx
add    $0x1,%rbx
add    $0x1,%rdi
cmp    $0x2,%rbx
jne    1a50 <subspace+0x850>
jmp    1a90 <subspace+0x890>
xchg   %ax,%ax
movl   $0x0,(%rsi)
lea    (%rax,%rdi,1),%rbx
mov    $0x1,%dl
cmp    $0x1,%rbx
jne    1a40 <subspace+0x840>
mov    %r8d,%r13d
jmp    1a08 <subspace+0x808>
nopw   0x0(%rax,%rax,1)
mov    %r8d,%r13d
test   $0x1,%dl
je     1a00 <subspace+0x800>
jmp    1a08 <subspace+0x808>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r9d,%ebp
mov    0x58(%rsp),%rsi
mov    0x8(%rsp),%rcx
cmpl   $0x0,(%r12,%r10,4)
jne    19a7 <subspace+0x7a7>
jmp    1ae4 <subspace+0x8e4>
nopw   0x0(%rax,%rax,1)
mov    $0x1,%ebp
movapd %xmm0,%xmm2
cmpl   $0x0,(%r12,%r10,4)
jne    19a7 <subspace+0x7a7>
mov    %rcx,%rdi
shr    $0x3,%rdi
mov    %r12,%rcx
mov    0x38(%rsp),%rbx
lea    -0x9(%rbx),%r12
add    $0x1,%rdi
mov    %r12,%rdx
shr    $0x3,%rdx
and    $0xfffffffffffffffe,%rdi
add    $0x1,%rdx
add    $0xffffffffffffffff,%rbx
mov    0x4(%rcx),%ebp
mov    $0x1,%r13d
cmp    $0x2,%r10
jb     198c <subspace+0x78c>
jne    1b32 <subspace+0x932>
mov    0x10(%rsp),%r12
mov    0x8(%rsp),%rcx
jmp    1cb2 <subspace+0xab2>
mov    %rbx,%rcx
mov    $0x2,%ebx
mov    %rcx,%r13
cmp    $0x8,%rcx
mov    0x8(%rsp),%rcx
jae    1b52 <subspace+0x952>
mov    0x10(%rsp),%r12
jmp    1ca0 <subspace+0xaa0>
movd   %ebp,%xmm1
pshufd $0x0,%xmm1,%xmm1
xor    %ecx,%ecx
movdqa %xmm1,%xmm2
cmp    $0x8,%r12
jae    1b74 <subspace+0x974>
mov    0x10(%rsp),%r12
mov    %r13,%rbx
jmp    1bf6 <subspace+0x9f6>
mov    0x10(%rsp),%r12
mov    %r13,%rbx
nopl   0x0(%rax)
movdqu 0x8(%r12,%rcx,4),%xmm3
movdqu 0x18(%r12,%rcx,4),%xmm4
movdqu 0x28(%r12,%rcx,4),%xmm5
movdqu 0x38(%r12,%rcx,4),%xmm6
movdqa %xmm1,%xmm7
pcmpgtd %xmm3,%xmm7
pand   %xmm7,%xmm1
pandn  %xmm3,%xmm7
por    %xmm1,%xmm7
movdqa %xmm2,%xmm3
pcmpgtd %xmm4,%xmm3
pand   %xmm3,%xmm2
pandn  %xmm4,%xmm3
por    %xmm2,%xmm3
movdqa %xmm7,%xmm1
pcmpgtd %xmm5,%xmm1
pand   %xmm1,%xmm7
pandn  %xmm5,%xmm1
por    %xmm7,%xmm1
movdqa %xmm3,%xmm2
pcmpgtd %xmm6,%xmm2
pand   %xmm2,%xmm3
pandn  %xmm6,%xmm2
por    %xmm3,%xmm2
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rdi
jne    1b80 <subspace+0x980>
mov    %rbx,%rdi
and    $0xfffffffffffffff8,%rbx
test   $0x1,%dl
je     1c3f <subspace+0xa3f>
shl    $0x2,%rcx
or     $0x8,%rcx
movdqu (%r12,%rcx,1),%xmm3
movdqu 0x10(%r12,%rcx,1),%xmm4
movdqa %xmm1,%xmm5
pcmpgtd %xmm3,%xmm5
pand   %xmm5,%xmm1
pandn  %xmm3,%xmm5
por    %xmm5,%xmm1
movdqa %xmm2,%xmm3
pcmpgtd %xmm4,%xmm3
pand   %xmm3,%xmm2
pandn  %xmm4,%xmm3
por    %xmm3,%xmm2
movdqa %xmm1,%xmm3
pcmpgtd %xmm2,%xmm3
pand   %xmm3,%xmm1
pandn  %xmm2,%xmm3
por    %xmm1,%xmm3
pshufd $0xee,%xmm3,%xmm1
movdqa %xmm3,%xmm2
pcmpgtd %xmm1,%xmm2
pand   %xmm2,%xmm3
pandn  %xmm1,%xmm2
por    %xmm3,%xmm2
pshufd $0x55,%xmm2,%xmm1
movdqa %xmm2,%xmm3
pcmpgtd %xmm1,%xmm3
pand   %xmm3,%xmm2
pandn  %xmm1,%xmm3
por    %xmm2,%xmm3
movd   %xmm3,%ebp
cmp    %rbx,%rdi
jne    1c95 <subspace+0xa95>
mov    0x8(%rsp),%rcx
jmp    1cb2 <subspace+0xab2>
or     $0x2,%rbx
mov    0x8(%rsp),%rcx
xchg   %ax,%ax
mov    (%r12,%rbx,4),%edx
cmp    %edx,%ebp
cmovl  %edx,%ebp
add    $0x1,%rbx
cmp    %rbx,%r10
jne    1ca0 <subspace+0xaa0>
mov    %r8d,%r13d
jmp    1996 <subspace+0x796>
mov    0x18(%rsp),%rax
test   %eax,%eax
mov    (%rsp),%rcx
mov    0x28(%rsp),%r10
movabs $0x3ff0000000000000,%r11
jle    1d71 <subspace+0xb71>
mov    $0x1,%eax
lea    0x14be(%rip),%r9
lea    0x14cf(%rip),%r8
movabs $0x3fc999999999999a,%rdi
99 c9 3f
jmp    1d2e <subspace+0xb2e>
nopl   0x0(%rax)
mov    (%r12,%rax,4),%edx
lea    (%rdx,%rbp,1),%esi
movslq %esi,%rsi
mov    (%r10,%rsi,8),%rsi
mov    %rdi,(%rsi,%rax,8)
add    %r13d,%edx
movslq %edx,%rdx
mov    (%r10,%rdx,8),%rdx
mov    %rdi,(%rdx,%rax,8)
add    $0x1,%rax
mov    0x58(%rsp),%rdx
cmp    %rax,%rdx
je     1d74 <subspace+0xb74>
movslq (%r12,%rax,4),%rdx
mov    (%r10,%rdx,8),%rbx
mov    %r11,(%rbx,%rax,8)
imul   $0x2aaaaaab,%rdx,%rbx
mov    %rbx,%rsi
shr    $0x3f,%rsi
shr    $0x20,%rbx
add    %esi,%ebx
add    %ebx,%ebx
lea    (%rbx,%rbx,2),%esi
sub    %esi,%edx
mov    0x328(%rsp),%rsi
mov    %edx,(%rsi)
cmp    $0x5,%edx
ja     1d00 <subspace+0xb00>
movslq %edx,%rdx
mov    (%r9,%rdx,4),%ebp
mov    (%r8,%rdx,4),%r13d
jmp    1d00 <subspace+0xb00>
lea    0x1(%rax),%edx
mov    0x320(%rsp),%rax
movl   $0x0,(%rax)
movslq 0x4c(%rsp),%rax
mov    %rax,0xa8(%rsp)
lea    0x1(%rcx),%eax
mov    %edx,%r12d
lea    -0x1(%rax),%rdx
lea    -0x2(%rax),%rsi
mov    %rsi,0xd8(%rsp)
mov    %edx,%ebp
and    $0x3,%ebp
mov    %rdx,0xc0(%rsp)
mov    %rdx,%rsi
and    $0xfffffffffffffffc,%rsi
xorpd  %xmm1,%xmm1
mov    %rax,0xb8(%rsp)
mov    %r12,0x38(%rsp)
mov    %rbp,0x58(%rsp)
mov    %rsi,0xd0(%rsp)
nopw   0x0(%rax,%rax,1)
movsd  %xmm1,0xc8(%rsp)
cmpl   $0x0,0x18(%rsp)
jle    1f80 <subspace+0xd80>
mov    $0x1,%r8d
jmp    1e0d <subspace+0xc0d>
nopl   0x0(%rax)
add    $0x1,%r8
cmp    %r12,%r8
je     1f80 <subspace+0xd80>
mov    %r14,%rdi
mov    %r10,%rsi
mov    0x68(%rsp),%rbx
mov    %rbx,%rdx
mov    %r8,0x8(%rsp)
mov    %rcx,%rbp
call   1030 <prodABj@plt>
mov    0x20(%rsp),%r13
mov    %r13,%rdi
mov    %ebp,%esi
mov    0x60(%rsp),%rbp
mov    %rbp,%rdx
mov    %rbx,%r14
mov    %rbx,%rcx
mov    %r15,%r8
xor    %r9d,%r9d
mov    0x328(%rsp),%rbx
push   %rbx
push   $0x1
call   1090 <ldl_dcmp@plt>
add    $0x10,%rsp
movl   $0x1,(%rbx)
movabs $0x3ff0000000000000,%rax
mov    %rax,0x88(%rsp)
lea    0x88(%rsp),%r12
nopw   0x0(%rax,%rax,1)
sub    $0x8,%rsp
mov    %r13,%rdi
mov    0x8(%rsp),%rsi
mov    %rbp,%rdx
mov    %r14,%rcx
mov    %r15,%r8
mov    %r12,%r9
push   %rbx
call   1060 <ldl_mprove@plt>
add    $0x10,%rsp
cmpl   $0x0,(%rbx)
jne    1e80 <subspace+0xc80>
mov    (%rsp),%rcx
test   %ecx,%ecx
mov    0x40(%rsp),%r14
mov    0x28(%rsp),%r10
mov    0x38(%rsp),%r12
mov    0x58(%rsp),%rbp
mov    0x8(%rsp),%r8
jle    1e00 <subspace+0xc00>
mov    $0x1,%eax
cmpq   $0x3,0xd8(%rsp)
jb     1f45 <subspace+0xd45>
xor    %eax,%eax
mov    0x30(%rsp),%rsi
mov    0xd0(%rsp),%rdi
nopl   0x0(%rax,%rax,1)
movsd  0x8(%r15,%rax,8),%xmm0
mov    0x8(%rsi,%rax,8),%rdx
movsd  %xmm0,(%rdx,%r8,8)
movsd  0x10(%r15,%rax,8),%xmm0
mov    0x10(%rsi,%rax,8),%rdx
movsd  %xmm0,(%rdx,%r8,8)
movsd  0x18(%r15,%rax,8),%xmm0
mov    0x18(%rsi,%rax,8),%rdx
movsd  %xmm0,(%rdx,%r8,8)
movsd  0x20(%r15,%rax,8),%xmm0
mov    0x20(%rsi,%rax,8),%rdx
movsd  %xmm0,(%rdx,%r8,8)
add    $0x4,%rax
cmp    %rax,%rdi
jne    1ef0 <subspace+0xcf0>
add    $0x1,%rax
test   %rbp,%rbp
je     1e00 <subspace+0xc00>
mov    0x30(%rsp),%rdx
lea    (%rdx,%rax,8),%rdi
lea    (%r15,%rax,8),%rax
xor    %edx,%edx
nopl   (%rax)
movsd  (%rax,%rdx,8),%xmm0
mov    (%rdi,%rdx,8),%rsi
movsd  %xmm0,(%rsi,%r8,8)
add    $0x1,%rdx
cmp    %rdx,%rbp
jne    1f60 <subspace+0xd60>
jmp    1e00 <subspace+0xc00>
nopl   (%rax)
mov    0x20(%rsp),%rdi
mov    0x30(%rsp),%r14
mov    %r14,%rsi
mov    0x80(%rsp),%rdx
mov    0x18(%rsp),%rbx
mov    %ebx,%r8d
mov    %rcx,%r13
call   1050 <xtAx@plt>
mov    0x40(%rsp),%rdi
mov    %r14,%rsi
mov    0x78(%rsp),%r14
mov    %r14,%rdx
mov    %r13d,%ecx
mov    %ebx,%r8d
call   1050 <xtAx@plt>
mov    0x80(%rsp),%rdi
mov    %r14,%rsi
mov    0x50(%rsp),%r13
mov    %r13,%rdx
mov    0xb0(%rsp),%r14
mov    %r14,%rcx
mov    %ebx,%r8d
call   1040 <jacobi@plt>
mov    0x30(%rsp),%rdi
mov    %r14,%rsi
mov    0x28(%rsp),%r14
mov    %r14,%rdx
mov    (%rsp),%rcx
mov    %ebx,%r8d
mov    %ebx,%r9d
call   10d0 <prodAB@plt>
mov    %r13,%rdi
mov    %r14,%rsi
mov    (%rsp),%rdx
mov    %ebx,%ecx
call   1120 <eigsort@plt>
mov    0xa8(%rsp),%rax
movsd  0x0(%r13,%rax,8),%xmm1
ucomisd 0xfeb(%rip),%xmm1
jne    2035 <subspace+0xe35>
jnp    221c <subspace+0x101c>
movapd %xmm1,%xmm0
subsd  0xc8(%rsp),%xmm0
andpd  0xfd6(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x88(%rsp)
mov    0x320(%rsp),%rcx
mov    (%rcx),%eax
lea    0x1(%rax),%edx
mov    %edx,(%rcx)
cmp    $0x7d0,%eax
movdqa 0x90(%rsp),%xmm7
jge    225d <subspace+0x105d>
ucomisd 0x70(%rsp),%xmm0
mov    (%rsp),%rcx
mov    0x40(%rsp),%r14
mov    0x28(%rsp),%r10
ja     1de0 <subspace+0xbe0>
cmpl   $0x0,0x18(%rsp)
jle    229d <subspace+0x109d>
lea    -0x1(%r12),%rcx
mov    $0x1,%eax
cmp    $0x4,%rcx
mov    0x50(%rsp),%rbp
mov    0x10(%rsp),%r13
jb     2150 <subspace+0xf50>
mov    %rcx,%rsi
and    $0xfffffffffffffffc,%rsi
lea    0x1(%rsi),%rax
movdqa %xmm7,%xmm8
punpcklqdq %xmm7,%xmm8
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd 0x8(%rbp,%rdi,8),%xmm2
movupd 0x18(%rbp,%rdi,8),%xmm3
movdqa %xmm8,%xmm4
cmpltpd %xmm2,%xmm4
movdqa %xmm8,%xmm5
cmpltpd %xmm3,%xmm5
movdqa %xmm8,%xmm6
subpd  %xmm2,%xmm6
movdqa %xmm8,%xmm1
subpd  %xmm3,%xmm1
subpd  %xmm8,%xmm2
subpd  %xmm8,%xmm3
andpd  %xmm4,%xmm2
andnpd %xmm6,%xmm4
orpd   %xmm2,%xmm4
andpd  %xmm5,%xmm3
andnpd %xmm1,%xmm5
orpd   %xmm3,%xmm5
movupd %xmm4,0x8(%rbp,%rdi,8)
movupd %xmm5,0x18(%rbp,%rdi,8)
add    $0x4,%rdi
cmp    %rdi,%rsi
jne    20e0 <subspace+0xee0>
cmp    %rsi,%rcx
je     2186 <subspace+0xf86>
xchg   %ax,%ax
movsd  0x0(%rbp,%rax,8),%xmm1
movdqa %xmm7,%xmm2
subsd  %xmm1,%xmm2
movdqa %xmm7,%xmm3
cmpltsd %xmm1,%xmm3
subsd  %xmm7,%xmm1
andpd  %xmm3,%xmm1
andnpd %xmm2,%xmm3
orpd   %xmm1,%xmm3
movlpd %xmm3,0x0(%rbp,%rax,8)
add    $0x1,%rax
cmp    %rax,%r12
jne    2150 <subspace+0xf50>
cmpl   $0x0,0x330(%rsp)
je     22be <subspace+0x10be>
mov    %r12,%r15
mov    0x2e42(%rip),%rax
mov    (%rax),%edi
lea    0xfaf(%rip),%rsi
mov    $0x1,%al
call   1080 <fprintf@plt>
cmpl   $0x0,0x18(%rsp)
jle    22be <subspace+0x10be>
mov    $0x1,%ebx
jmp    21f4 <subspace+0xff4>
call   1100 <sqrt@plt>
divsd  0xe43(%rip),%xmm0
mov    %ebp,%edi
lea    0xfab(%rip),%rsi
mov    %ebx,%edx
mov    %r12d,%ecx
mov    $0x1,%al
call   1080 <fprintf@plt>
add    $0x1,%rbx
cmp    %rbx,%r15
mov    0x10(%rsp),%r13
je     22be <subspace+0x10be>
mov    0x2de5(%rip),%rax
mov    (%rax),%ebp
mov    0x0(%r13,%rbx,4),%r12d
mov    0x50(%rsp),%rax
movsd  (%rax,%rbx,8),%xmm0
ucomisd 0xe04(%rip),%xmm0
jb     21c0 <subspace+0xfc0>
sqrtsd %xmm0,%xmm0
jmp    21c5 <subspace+0xfc5>
xorps  %xmm0,%xmm0
cvtsi2sdl 0x4c(%rsp),%xmm0
lea    0xebe(%rip),%rsi
lea    0xe0(%rsp),%rbx
mov    %rbx,%rdi
mov    $0x2,%al
call   1110 <sprintf@plt>
mov    %rbx,%rdi
call   10a0 <errorMsg@plt>
mov    $0x20,%eax
add    $0x2e8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0xeb6(%rip),%rsi
lea    0xe0(%rsp),%rbx
mov    %rbx,%rdi
movsd  0x70(%rsp),%xmm1
jmp    2237 <subspace+0x1037>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
lea    0xe49(%rip),%rsi
lea    0xe0(%rsp),%rbx
mov    %rbx,%rdi
movapd %xmm0,%xmm1
mov    $0x3,%al
call   1110 <sprintf@plt>
jmp    223e <subspace+0x103e>
cmpl   $0x0,0x330(%rsp)
je     22be <subspace+0x10be>
mov    0x2d32(%rip),%rax
mov    (%rax),%edi
lea    0xe9f(%rip),%rsi
mov    $0x1,%al
call   1080 <fprintf@plt>
movsd  0x70(%rsp),%xmm1
mov    0x50(%rsp),%rax
mov    0xa8(%rsp),%rcx
addsd  (%rax,%rcx,8),%xmm1
mov    0x20(%rsp),%rdi
mov    %r14,%rsi
mov    (%rsp),%rbx
mov    %ebx,%edx
mov    0x18(%rsp),%r12
mov    %r12d,%ecx
movapd 0x90(%rsp),%xmm0
mov    0x330(%rsp),%r8d
call   10c0 <sturm@plt>
movdqa 0x90(%rsp),%xmm6
mov    0x328(%rsp),%rcx
mov    %eax,(%rcx)
test   %ebx,%ebx
mov    0xb8(%rsp),%rsi
jle    2538 <subspace+0x1338>
pxor   0xd03(%rip),%xmm6
pshufd $0x44,%xmm6,%xmm0
mov    %rsi,%r8
neg    %r8
lea    -0x5(%rsi),%r10
mov    $0x1,%r13d
mov    $0x7,%r11d
xor    %r14d,%r14d
jmp    2369 <subspace+0x1169>
nopl   (%rax)
add    $0x1,%r13
add    $0x1,%r14
add    $0x1,%r11
add    $0xffffffffffffffff,%r10
cmp    %rsi,%r13
je     2538 <subspace+0x1338>
mov    %r14,%r15
not    %r15
add    %rsi,%r15
mov    0x40(%rsp),%rax
mov    (%rax,%r13,8),%rbp
mov    0x20(%rsp),%rax
mov    (%rax,%r13,8),%rbx
mov    %r13,%rdx
cmp    $0x4,%r15
jb     24d0 <subspace+0x12d0>
lea    (%rbx,%r13,8),%rax
lea    0x0(,%rsi,8),%rcx
add    %rbp,%rcx
cmp    %rcx,%rax
jae    23c0 <subspace+0x11c0>
lea    (%rbx,%rsi,8),%rax
lea    0x0(,%r13,8),%rcx
add    %rbp,%rcx
mov    %r13,%rdx
cmp    %rax,%rcx
jb     24d0 <subspace+0x12d0>
mov    0xc0(%rsp),%rax
sub    %r14,%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,%r9
shr    $0x2,%r9
add    $0x1,%r9
cmp    $0x4,%rax
jae    23e7 <subspace+0x11e7>
xor    %ecx,%ecx
jmp    247f <subspace+0x127f>
mov    %r10,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
and    $0xfffffffffffffffe,%rdx
lea    (%rbx,%r11,8),%rax
lea    0x0(,%r11,8),%rdi
add    %rbp,%rdi
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movupd -0x30(%rdi,%rcx,8),%xmm1
movupd -0x20(%rdi,%rcx,8),%xmm2
mulpd  %xmm0,%xmm1
movupd -0x30(%rax,%rcx,8),%xmm3
addpd  %xmm1,%xmm3
movupd -0x20(%rax,%rcx,8),%xmm1
movupd -0x10(%rax,%rcx,8),%xmm4
movupd (%rax,%rcx,8),%xmm5
mulpd  %xmm0,%xmm2
addpd  %xmm1,%xmm2
movupd %xmm3,-0x30(%rax,%rcx,8)
movupd %xmm2,-0x20(%rax,%rcx,8)
movupd -0x10(%rdi,%rcx,8),%xmm1
movupd (%rdi,%rcx,8),%xmm2
mulpd  %xmm0,%xmm1
addpd  %xmm4,%xmm1
mulpd  %xmm0,%xmm2
addpd  %xmm5,%xmm2
movupd %xmm1,-0x10(%rax,%rcx,8)
movupd %xmm2,(%rax,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rdx
jne    2410 <subspace+0x1210>
mov    %r15,%rdx
and    $0xfffffffffffffffc,%rdx
test   $0x1,%r9b
je     24c1 <subspace+0x12c1>
add    %r13,%rcx
movupd 0x0(%rbp,%rcx,8),%xmm1
movupd 0x10(%rbp,%rcx,8),%xmm2
movupd (%rbx,%rcx,8),%xmm3
movupd 0x10(%rbx,%rcx,8),%xmm4
mulpd  %xmm0,%xmm1
addpd  %xmm3,%xmm1
mulpd  %xmm0,%xmm2
addpd  %xmm4,%xmm2
movupd %xmm1,(%rbx,%rcx,8)
movupd %xmm2,0x10(%rbx,%rcx,8)
cmp    %rdx,%r15
je     2350 <subspace+0x1150>
add    %r13,%rdx
nopl   (%rax)
mov    %esi,%ecx
sub    %edx,%ecx
mov    %rdx,%rax
test   $0x1,%cl
je     24f4 <subspace+0x12f4>
movsd  0x0(%rbp,%rdx,8),%xmm1
mulsd  %xmm6,%xmm1
addsd  (%rbx,%rdx,8),%xmm1
movsd  %xmm1,(%rbx,%rdx,8)
lea    0x1(%rdx),%rax
not    %rdx
cmp    %r8,%rdx
je     2350 <subspace+0x1150>
movsd  0x0(%rbp,%rax,8),%xmm1
mulsd  %xmm6,%xmm1
addsd  (%rbx,%rax,8),%xmm1
movsd  %xmm1,(%rbx,%rax,8)
movsd  0x8(%rbp,%rax,8),%xmm1
mulsd  %xmm6,%xmm1
addsd  0x8(%rbx,%rax,8),%xmm1
movsd  %xmm1,0x8(%rbx,%rax,8)
add    $0x2,%rax
cmp    %rax,%rsi
jne    2500 <subspace+0x1300>
jmp    2350 <subspace+0x1150>
mov    0x80(%rsp),%rdi
mov    $0x1,%esi
mov    %r12d,%edx
mov    $0x1,%ecx
mov    %r12d,%r8d
call   10f0 <free_dmatrix@plt>
mov    0x78(%rsp),%rdi
mov    $0x1,%esi
mov    %r12d,%edx
mov    $0x1,%ecx
mov    %r12d,%r8d
call   10f0 <free_dmatrix@plt>
mov    0x30(%rsp),%rdi
mov    $0x1,%esi
mov    (%rsp),%rdx
mov    $0x1,%ecx
mov    %r12d,%r8d
call   10f0 <free_dmatrix@plt>
mov    0xb0(%rsp),%rdi
mov    $0x1,%esi
mov    %r12d,%edx
mov    $0x1,%ecx
mov    %r12d,%r8d
call   10f0 <free_dmatrix@plt>
xor    %eax,%eax
jmp    224b <subspace+0x104b>

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

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