#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 *);
int /*<<< orphan*/ exit(int);
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);
void 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);
    exit(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);
      exit(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);
      exit(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 > 1000) {
      sprintf(errMsg,
              "  subspace: Iteration limit exceeded\n rel. error = %e > %e\n",
              error, tol);
      errorMsg(errMsg);
      exit(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;
}


x86 assembly (clang, -O0):
<subspace>:
push   %rbp
mov    %rsp,%rbp
sub    $0x2e0,%rsp
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
movsd  %xmm0,-0x30(%rbp)
movsd  %xmm1,-0x38(%rbp)
movsd  0x1db2(%rip),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movl   $0x0,-0x94(%rbp)
movl   $0x0,-0x98(%rbp)
movl   $0x0,-0x9c(%rbp)
movl   $0x0,-0xa4(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jle    12ca <subspace+0xba>
lea    -0x2b0(%rbp),%rdi
cvtsi2sdl -0x18(%rbp),%xmm0
cvtsi2sdl -0x14(%rbp),%xmm1
lea    0x1dab(%rip),%rsi
mov    $0x2,%al
call   1110 <sprintf@plt>
lea    -0x2b0(%rbp),%rdi
call   10a0 <errorMsg@plt>
mov    $0x20,%edi
call   1120 <exit@plt>
mov    -0x14(%rbp),%esi
mov    $0x1,%edi
call   10b0 <dvector@plt>
mov    %rax,-0x60(%rbp)
mov    -0x14(%rbp),%esi
mov    $0x1,%edi
call   10b0 <dvector@plt>
mov    %rax,-0x68(%rbp)
mov    -0x14(%rbp),%esi
mov    $0x1,%edi
call   10b0 <dvector@plt>
mov    %rax,-0x70(%rbp)
mov    -0x18(%rbp),%esi
mov    -0x18(%rbp),%ecx
mov    $0x1,%edx
mov    %edx,%edi
call   1070 <dmatrix@plt>
mov    %rax,-0x40(%rbp)
mov    -0x18(%rbp),%esi
mov    -0x18(%rbp),%ecx
mov    $0x1,%edx
mov    %edx,%edi
call   1070 <dmatrix@plt>
mov    %rax,-0x48(%rbp)
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%ecx
mov    $0x1,%edx
mov    %edx,%edi
call   1070 <dmatrix@plt>
mov    %rax,-0x50(%rbp)
mov    -0x18(%rbp),%esi
mov    -0x18(%rbp),%ecx
mov    $0x1,%edx
mov    %edx,%edi
call   1070 <dmatrix@plt>
mov    %rax,-0x58(%rbp)
mov    -0x18(%rbp),%esi
mov    $0x1,%edi
call   10e0 <ivector@plt>
mov    %rax,-0xb0(%rbp)
movl   $0x1,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     1493 <subspace+0x283>
mov    -0xb0(%rbp),%rax
movslq -0x94(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x94(%rbp),%eax
mov    %eax,-0x98(%rbp)
mov    -0x98(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     147a <subspace+0x26a>
mov    -0x58(%rbp),%rax
movslq -0x98(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x94(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x58(%rbp),%rax
movslq -0x94(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x98(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%rax
movslq -0x98(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x94(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%rax
movslq -0x94(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x98(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%rax
movslq -0x98(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x94(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%rax
movslq -0x94(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x98(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    13a3 <subspace+0x193>
jmp    147f <subspace+0x26f>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    1373 <subspace+0x163>
movl   $0x1,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     152e <subspace+0x31e>
movl   $0x1,-0x98(%rbp)
mov    -0x98(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     1515 <subspace+0x305>
mov    -0x28(%rbp),%rax
movslq -0x94(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x98(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%rax
movslq -0x94(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x98(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    14b6 <subspace+0x2a6>
jmp    151a <subspace+0x30a>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    149d <subspace+0x28d>
cvtsi2sdl -0x18(%rbp),%xmm1
movsd  0x1ad5(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsi2sdl -0x18(%rbp),%xmm1
movsd  0x1abc(%rip),%xmm2
subsd  %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jbe    157a <subspace+0x36a>
cvtsi2sdl -0x18(%rbp),%xmm0
movsd  0x1ab1(%rip),%xmm1
divsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x2b4(%rbp)
jmp    1586 <subspace+0x376>
mov    -0x18(%rbp),%eax
sub    $0x8,%eax
mov    %eax,-0x2b4(%rbp)
mov    -0x2b4(%rbp),%eax
mov    %eax,-0xa0(%rbp)
movl   $0x1,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     163b <subspace+0x42b>
mov    -0x94(%rbp),%eax
mov    %eax,-0x98(%rbp)
mov    -0x98(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1622 <subspace+0x412>
movsd  -0x38(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x94(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x98(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x94(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x98(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    15b7 <subspace+0x3a7>
jmp    1627 <subspace+0x417>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    159c <subspace+0x38c>
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x68(%rbp),%rdx
mov    -0x70(%rbp),%rcx
mov    -0x70(%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,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1759 <subspace+0x549>
mov    -0x10(%rbp),%rax
movslq -0x94(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x94(%rbp),%rcx
xorps  %xmm0,%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jb     16ff <subspace+0x4ef>
lea    -0x2b0(%rbp),%rdi
cvtsi2sdl -0x94(%rbp),%xmm0
ff
cvtsi2sdl -0x94(%rbp),%xmm1
ff
mov    -0x10(%rbp),%rax
movslq -0x94(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x94(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
lea    0x1a04(%rip),%rsi
mov    $0x3,%al
call   1110 <sprintf@plt>
lea    -0x2b0(%rbp),%rdi
call   10a0 <errorMsg@plt>
mov    $0x20,%edi
call   1120 <exit@plt>
mov    -0x8(%rbp),%rax
movslq -0x94(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x94(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x94(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x94(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
movslq -0x94(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    1676 <subspace+0x466>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
movl   $0x1,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     1984 <subspace+0x774>
mov    -0x60(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x78(%rbp)
movl   $0x1,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     18a1 <subspace+0x691>
movsd  -0x80(%rbp),%xmm1
mov    -0x60(%rbp),%rax
movslq -0x94(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jb     1888 <subspace+0x678>
mov    -0x60(%rbp),%rax
movslq -0x94(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x78(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     1888 <subspace+0x678>
mov    0x18(%rbp),%rax
movl   $0x1,(%rax)
movl   $0x1,-0x98(%rbp)
mov    -0x98(%rbp),%eax
mov    -0x9c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     184a <subspace+0x63a>
mov    -0x94(%rbp),%eax
mov    -0xb0(%rbp),%rcx
movslq -0x98(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jne    1831 <subspace+0x621>
mov    0x18(%rbp),%rax
movl   $0x0,(%rax)
jmp    1836 <subspace+0x626>
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    17f3 <subspace+0x5e3>
mov    0x18(%rbp),%rax
cmpl   $0x0,(%rax)
je     1883 <subspace+0x673>
mov    -0x60(%rbp),%rax
movslq -0x94(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x94(%rbp),%edx
mov    -0xb0(%rbp),%rax
movslq -0x9c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1888 <subspace+0x678>
jmp    188d <subspace+0x67d>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    1792 <subspace+0x582>
mov    -0xb0(%rbp),%rax
movslq -0x9c(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    1966 <subspace+0x756>
mov    -0xb0(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x94(%rbp)
movl   $0x1,-0x98(%rbp)
mov    -0x98(%rbp),%eax
cmp    -0x9c(%rbp),%eax
jge    1932 <subspace+0x722>
mov    -0x94(%rbp),%eax
mov    -0xb0(%rbp),%rcx
movslq -0x98(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1919 <subspace+0x709>
mov    -0xb0(%rbp),%rax
movslq -0x98(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x94(%rbp)
jmp    191e <subspace+0x70e>
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    18d3 <subspace+0x6c3>
mov    -0x94(%rbp),%edx
add    $0x1,%edx
mov    -0xb0(%rbp),%rax
movslq -0x9c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x60(%rbp),%rax
mov    -0x94(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    176b <subspace+0x55b>
movl   $0x1,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     1b3b <subspace+0x92b>
mov    -0x28(%rbp),%rax
mov    -0xb0(%rbp),%rdx
movslq -0x9c(%rbp),%rcx
movslq (%rdx,%rcx,4),%rdx
mov    (%rax,%rdx,8),%rax
movabs $0x3ff0000000000000,%rdx
mov    %rdx,(%rax,%rcx,8)
mov    -0xb0(%rbp),%rax
movslq -0x9c(%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,-0x2c0(%rbp)
sub    $0x5,%rax
ja     1abb <subspace+0x8ab>
mov    -0x2c0(%rbp),%rax
lea    0x161f(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movl   $0x1,-0x94(%rbp)
movl   $0x2,-0x98(%rbp)
jmp    1abb <subspace+0x8ab>
movl   $0xffffffff,-0x94(%rbp)
ff ff ff
movl   $0x1,-0x98(%rbp)
jmp    1abb <subspace+0x8ab>
movl   $0xffffffff,-0x94(%rbp)
ff ff ff
movl   $0xfffffffe,-0x98(%rbp)
ff ff ff
jmp    1abb <subspace+0x8ab>
movl   $0x1,-0x94(%rbp)
movl   $0x2,-0x98(%rbp)
jmp    1abb <subspace+0x8ab>
movl   $0xffffffff,-0x94(%rbp)
ff ff ff
movl   $0x1,-0x98(%rbp)
jmp    1abb <subspace+0x8ab>
movl   $0xffffffff,-0x94(%rbp)
ff ff ff
movl   $0xfffffffe,-0x98(%rbp)
ff ff ff
mov    -0x28(%rbp),%rax
mov    -0xb0(%rbp),%rcx
movslq -0x9c(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
add    -0x94(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x9c(%rbp),%rcx
movsd  0x153c(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
mov    -0xb0(%rbp),%rcx
movslq -0x9c(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
add    -0x98(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x9c(%rbp),%rcx
movsd  0x1506(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    198e <subspace+0x77e>
mov    0x10(%rbp),%rax
movl   $0x0,(%rax)
movl   $0x1,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     1cdc <subspace+0xacc>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%rsi
mov    -0x70(%rbp),%rdx
mov    -0x14(%rbp),%ecx
mov    -0x9c(%rbp),%r8d
call   1030 <prodABj@plt>
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x68(%rbp),%rdx
mov    -0x70(%rbp),%rcx
mov    -0x60(%rbp),%r8
mov    0x18(%rbp),%rax
xor    %r9d,%r9d
movl   $0x1,(%rsp)
mov    %rax,0x8(%rsp)
call   1090 <ldl_dcmp@plt>
cmpl   $0x0,-0xa4(%rbp)
je     1bc8 <subspace+0x9b8>
mov    0x3428(%rip),%rax
mov    (%rax),%edi
lea    0x1541(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    0x18(%rbp),%rax
movl   $0x1,(%rax)
movsd  0x1426(%rip),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x68(%rbp),%rdx
mov    -0x70(%rbp),%rcx
mov    -0x60(%rbp),%r8
mov    0x18(%rbp),%rax
lea    -0x88(%rbp),%r9
mov    %rax,(%rsp)
call   1060 <ldl_mprove@plt>
cmpl   $0x0,-0xa4(%rbp)
je     1c35 <subspace+0xa25>
mov    0x33c3(%rip),%rax
mov    (%rax),%edi
movsd  -0x88(%rbp),%xmm0
ff
lea    0x14e8(%rip),%rsi
mov    $0x1,%al
call   1080 <fprintf@plt>
jmp    1c3a <subspace+0xa2a>
mov    0x18(%rbp),%rax
cmpl   $0x0,(%rax)
jne    1be2 <subspace+0x9d2>
cmpl   $0x0,-0xa4(%rbp)
je     1c6b <subspace+0xa5b>
mov    0x3385(%rip),%rax
mov    (%rax),%edi
lea    0x1480(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
movl   $0x1,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1cc3 <subspace+0xab3>
mov    -0x60(%rbp),%rax
movslq -0x94(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x94(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x9c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    1c75 <subspace+0xa65>
jmp    1cc8 <subspace+0xab8>
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    1b4f <subspace+0x93f>
mov    -0x8(%rbp),%rdi
mov    -0x50(%rbp),%rsi
mov    -0x40(%rbp),%rdx
mov    -0x14(%rbp),%ecx
mov    -0x18(%rbp),%r8d
call   1050 <xtAx@plt>
mov    -0x10(%rbp),%rdi
mov    -0x50(%rbp),%rsi
mov    -0x48(%rbp),%rdx
mov    -0x14(%rbp),%ecx
mov    -0x18(%rbp),%r8d
call   1050 <xtAx@plt>
mov    -0x40(%rbp),%rdi
mov    -0x48(%rbp),%rsi
mov    -0x20(%rbp),%rdx
mov    -0x58(%rbp),%rcx
mov    -0x18(%rbp),%r8d
call   1040 <jacobi@plt>
mov    -0x50(%rbp),%rdi
mov    -0x58(%rbp),%rsi
mov    -0x28(%rbp),%rdx
mov    -0x14(%rbp),%ecx
mov    -0x18(%rbp),%r8d
mov    -0x18(%rbp),%r9d
call   10d0 <prodAB@plt>
mov    -0x20(%rbp),%rdi
mov    -0x28(%rbp),%rsi
mov    -0x14(%rbp),%edx
mov    -0x18(%rbp),%ecx
call   1130 <eigsort@plt>
mov    -0x20(%rbp),%rax
movslq -0xa0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1dba <subspace+0xbaa>
jp     1dba <subspace+0xbaa>
lea    -0x2b0(%rbp),%rdi
cvtsi2sdl -0xa0(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movslq -0xa0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
lea    0x137f(%rip),%rsi
mov    $0x2,%al
call   1110 <sprintf@plt>
lea    -0x2b0(%rbp),%rdi
call   10a0 <errorMsg@plt>
mov    $0x20,%edi
call   1120 <exit@plt>
mov    -0x20(%rbp),%rax
movslq -0xa0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x90(%rbp),%xmm0
ff
movaps 0x1257(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0xa0(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    0x10(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
cmpl   $0x0,-0xa4(%rbp)
je     1e48 <subspace+0xc38>
mov    0x31cc(%rip),%rax
mov    (%rax),%edi
mov    0x10(%rbp),%rax
mov    (%rax),%edx
mov    -0xa0(%rbp),%ecx
mov    -0x20(%rbp),%rax
movslq -0xa0(%rbp),%rsi
movsd  (%rax,%rsi,8),%xmm0
movsd  -0x88(%rbp),%xmm1
ff
lea    0x130b(%rip),%rsi
mov    $0x2,%al
call   1080 <fprintf@plt>
mov    -0x20(%rbp),%rax
movslq -0xa0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    0x10(%rbp),%rax
cmpl   $0x3e8,(%rax)
jle    1ea8 <subspace+0xc98>
lea    -0x2b0(%rbp),%rdi
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x30(%rbp),%xmm1
lea    0x12e4(%rip),%rsi
mov    $0x2,%al
call   1110 <sprintf@plt>
lea    -0x2b0(%rbp),%rdi
call   10a0 <errorMsg@plt>
mov    $0x20,%edi
call   1120 <exit@plt>
jmp    1ead <subspace+0xc9d>
movsd  -0x88(%rbp),%xmm0
ff
ucomisd -0x30(%rbp),%xmm0
ja     1b45 <subspace+0x935>
movl   $0x1,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     1f5c <subspace+0xd4c>
mov    -0x20(%rbp),%rax
movslq -0x9c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0x38(%rbp),%xmm0
jbe    1f1e <subspace+0xd0e>
mov    -0x20(%rbp),%rax
movslq -0x9c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x38(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x9c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1f43 <subspace+0xd33>
movsd  -0x38(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x9c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x9c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1f48 <subspace+0xd38>
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    1eca <subspace+0xcba>
cmpl   $0x0,0x20(%rbp)
je     2030 <subspace+0xe20>
mov    0x3073(%rip),%rax
mov    (%rax),%edi
mov    0x10(%rbp),%rax
mov    (%rax),%edx
movsd  -0x88(%rbp),%xmm0
ff
lea    0x1227(%rip),%rsi
mov    $0x1,%al
call   1080 <fprintf@plt>
movl   $0x1,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     202b <subspace+0xe1b>
mov    0x3035(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x2cc(%rbp)
mov    -0x9c(%rbp),%eax
mov    %eax,-0x2c8(%rbp)
mov    -0xb0(%rbp),%rax
movslq -0x9c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x2c4(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x9c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1100 <sqrt@plt>
mov    -0x2cc(%rbp),%edi
mov    -0x2c8(%rbp),%edx
mov    -0x2c4(%rbp),%ecx
movsd  0x101b(%rip),%xmm1
divsd  %xmm1,%xmm0
lea    0x11c6(%rip),%rsi
mov    $0x1,%al
call   1080 <fprintf@plt>
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    1f95 <subspace+0xd85>
jmp    2030 <subspace+0xe20>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x14(%rbp),%edx
mov    -0x18(%rbp),%ecx
movsd  -0x38(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0xa0(%rbp),%r8
movsd  (%rax,%r8,8),%xmm1
addsd  -0x30(%rbp),%xmm1
mov    0x20(%rbp),%r8d
call   10c0 <sturm@plt>
mov    %eax,%ecx
mov    0x18(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     212a <subspace+0xf1a>
mov    -0x94(%rbp),%eax
mov    %eax,-0x98(%rbp)
mov    -0x98(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     2111 <subspace+0xf01>
movsd  -0x38(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x94(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x98(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x94(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x98(%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    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    208f <subspace+0xe7f>
jmp    2116 <subspace+0xf06>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    2074 <subspace+0xe64>
mov    -0x40(%rbp),%rdi
mov    -0x18(%rbp),%edx
mov    -0x18(%rbp),%r8d
mov    $0x1,%ecx
mov    %ecx,%esi
call   10f0 <free_dmatrix@plt>
mov    -0x48(%rbp),%rdi
mov    -0x18(%rbp),%edx
mov    -0x18(%rbp),%r8d
mov    $0x1,%ecx
mov    %ecx,%esi
call   10f0 <free_dmatrix@plt>
mov    -0x50(%rbp),%rdi
mov    -0x14(%rbp),%edx
mov    -0x18(%rbp),%r8d
mov    $0x1,%ecx
mov    %ecx,%esi
call   10f0 <free_dmatrix@plt>
mov    -0x58(%rbp),%rdi
mov    -0x18(%rbp),%edx
mov    -0x18(%rbp),%r8d
mov    $0x1,%ecx
mov    %ecx,%esi
call   10f0 <free_dmatrix@plt>
add    $0x2e0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<subspace>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x2e8,%rsp
movaps %xmm1,0x80(%rsp)
movsd  %xmm0,0x58(%rsp)
mov    %r9,0x50(%rsp)
mov    %r8,0xb8(%rsp)
mov    %edx,%ebp
mov    %rsi,0x40(%rsp)
movabs $0x3ff0000000000000,%rax
mov    %rax,0x78(%rsp)
xorps  %xmm0,%xmm0
cvtsi2sd %ecx,%xmm0
movsd  %xmm0,0x20(%rsp)
cmp    %edx,%ecx
jg     25fa <subspace+0x13ea>
mov    %ecx,%ebx
mov    %rdi,%r14
mov    $0x1,%edi
mov    %ebp,%esi
call   10b0 <dvector@plt>
mov    %rax,0x8(%rsp)
mov    $0x1,%edi
mov    %ebp,%esi
call   10b0 <dvector@plt>
mov    %rax,0x70(%rsp)
mov    $0x1,%edi
mov    %ebp,%esi
call   10b0 <dvector@plt>
mov    %rax,0x30(%rsp)
mov    $0x1,%edi
mov    %ebx,%esi
mov    $0x1,%edx
mov    %ebx,%ecx
call   1070 <dmatrix@plt>
mov    %rax,%r13
mov    $0x1,%edi
mov    %ebx,%esi
mov    $0x1,%edx
mov    %ebx,%ecx
call   1070 <dmatrix@plt>
mov    %rax,0x68(%rsp)
mov    $0x1,%edi
mov    %rbp,(%rsp)
mov    %ebp,%esi
mov    $0x1,%edx
mov    %ebx,%ecx
call   1070 <dmatrix@plt>
mov    %rax,0x28(%rsp)
mov    $0x1,%edi
mov    %ebx,%esi
mov    $0x1,%edx
mov    %ebx,%ecx
call   1070 <dmatrix@plt>
mov    %rax,0x60(%rsp)
mov    $0x1,%edi
mov    %ebx,%esi
call   10e0 <ivector@plt>
test   %ebx,%ebx
mov    %rbx,0x10(%rsp)
mov    %r14,0x38(%rsp)
mov    %rax,0x18(%rsp)
mov    %r13,0xa8(%rsp)
jle    13ec <subspace+0x1dc>
lea    0x1(%rbx),%r12d
mov    $0x1,%edx
movapd 0x80(%rsp),%xmm6
mov    0x68(%rsp),%r9
mov    0x60(%rsp),%r10
movsd  0x20(%rsp),%xmm1
jmp    1362 <subspace+0x152>
add    $0x1,%rdx
cmp    %r12,%rdx
mov    0x18(%rsp),%rax
je     13fe <subspace+0x1ee>
movl   $0x0,(%rax,%rdx,4)
mov    (%r10,%rdx,8),%r8
mov    (%r9,%rdx,8),%rax
mov    0x0(%r13,%rdx,8),%rsi
movq   $0x0,(%r8,%rdx,8)
movq   $0x0,(%rax,%rdx,8)
movq   $0x0,(%rsi,%rdx,8)
lea    0x1(%rdx),%rdi
cmp    %r12,%rdi
je     1350 <subspace+0x140>
nopw   0x0(%rax,%rax,1)
mov    (%r10,%rdi,8),%rbp
mov    (%r9,%rdi,8),%rbx
mov    0x0(%r13,%rdi,8),%rcx
movq   $0x0,0x0(%rbp,%rdx,8)
movq   $0x0,(%r8,%rdi,8)
movq   $0x0,(%rbx,%rdx,8)
movq   $0x0,(%rax,%rdi,8)
movq   $0x0,(%rcx,%rdx,8)
movq   $0x0,(%rsi,%rdi,8)
add    $0x1,%rdi
cmp    %rdi,%r12
jne    13a0 <subspace+0x190>
jmp    1350 <subspace+0x140>
xor    %r12d,%r12d
movapd 0x80(%rsp),%xmm6
movsd  0x20(%rsp),%xmm1
cmpl   $0x0,(%rsp)
mov    0x28(%rsp),%rdx
jle    1637 <subspace+0x427>
mov    0x10(%rsp),%rax
add    $0x1,%eax
mov    (%rsp),%rcx
lea    0x1(%rcx),%r13d
lea    -0x1(%rax),%r10
lea    -0x5(%rax),%r9
mov    %r9,%r11
shr    $0x2,%r11
add    $0x1,%r11
mov    %r10,%r8
and    $0xfffffffffffffffc,%r8
lea    0x1(%r8),%r15
mov    %r11d,%r14d
and    $0x3,%r14d
and    $0xfffffffffffffffc,%r11
mov    $0x1,%ebp
xorpd  %xmm0,%xmm0
jmp    1478 <subspace+0x268>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    $0x1,%r12d
add    $0x1,%rbp
cmp    %r13,%rbp
mov    0x28(%rsp),%rdx
je     1637 <subspace+0x427>
cmpl   $0x0,0x10(%rsp)
jle    1460 <subspace+0x250>
mov    0x50(%rsp),%rcx
mov    (%rcx,%rbp,8),%rsi
mov    (%rdx,%rbp,8),%rdi
mov    $0x1,%edx
cmp    $0x4,%r10
jb     1590 <subspace+0x380>
lea    0x8(%rsi),%rcx
lea    (%rdi,%rax,8),%rbx
cmp    %rbx,%rcx
jae    14b9 <subspace+0x2a9>
lea    (%rsi,%rax,8),%rcx
lea    0x8(%rdi),%rbx
cmp    %rcx,%rbx
jb     1590 <subspace+0x380>
cmp    $0xc,%r9
jae    14c3 <subspace+0x2b3>
xor    %edx,%edx
jmp    153a <subspace+0x32a>
mov    %r11,%rcx
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movupd %xmm0,0x8(%rsi,%rdx,8)
movupd %xmm0,0x18(%rsi,%rdx,8)
movupd %xmm0,0x8(%rdi,%rdx,8)
movupd %xmm0,0x18(%rdi,%rdx,8)
movupd %xmm0,0x28(%rsi,%rdx,8)
movupd %xmm0,0x38(%rsi,%rdx,8)
movupd %xmm0,0x28(%rdi,%rdx,8)
movupd %xmm0,0x38(%rdi,%rdx,8)
movupd %xmm0,0x48(%rsi,%rdx,8)
movupd %xmm0,0x58(%rsi,%rdx,8)
movupd %xmm0,0x48(%rdi,%rdx,8)
movupd %xmm0,0x58(%rdi,%rdx,8)
movupd %xmm0,0x68(%rsi,%rdx,8)
movupd %xmm0,0x78(%rsi,%rdx,8)
movupd %xmm0,0x68(%rdi,%rdx,8)
movupd %xmm0,0x78(%rdi,%rdx,8)
add    $0x10,%rdx
add    $0xfffffffffffffffc,%rcx
jne    14d0 <subspace+0x2c0>
test   %r14,%r14
je     157c <subspace+0x36c>
mov    %r14,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    0x0(,%rdx,8),%rbx
or     $0x8,%rbx
movupd %xmm0,(%rsi,%rbx,1)
movupd %xmm0,0x10(%rsi,%rbx,1)
movupd %xmm0,(%rdi,%rbx,1)
movupd %xmm0,0x10(%rdi,%rbx,1)
add    $0x4,%rdx
add    $0xffffffffffffffff,%rcx
jne    1550 <subspace+0x340>
mov    %r15,%rdx
mov    %eax,%r12d
cmp    %r8,%r10
je     1466 <subspace+0x256>
nopl   0x0(%rax,%rax,1)
mov    %eax,%ebx
sub    %edx,%ebx
mov    %rdx,%rcx
not    %rcx
add    %rax,%rcx
and    $0x3,%rbx
je     15ca <subspace+0x3ba>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movq   $0x0,(%rsi,%rdx,8)
movq   $0x0,(%rdi,%rdx,8)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rbx
jne    15b0 <subspace+0x3a0>
mov    %eax,%r12d
cmp    $0x3,%rcx
jb     1466 <subspace+0x256>
nopw   0x0(%rax,%rax,1)
movq   $0x0,(%rsi,%rdx,8)
movq   $0x0,(%rdi,%rdx,8)
movq   $0x0,0x8(%rsi,%rdx,8)
movq   $0x0,0x8(%rdi,%rdx,8)
movq   $0x0,0x10(%rsi,%rdx,8)
movq   $0x0,0x10(%rdi,%rdx,8)
movq   $0x0,0x18(%rsi,%rdx,8)
movq   $0x0,0x18(%rdi,%rdx,8)
add    $0x4,%rdx
cmp    %rdx,%rax
jne    15e0 <subspace+0x3d0>
mov    %eax,%r12d
jmp    1466 <subspace+0x256>
mov    0x328(%rsp),%rbp
movsd  0x19b9(%rip),%xmm0
mulsd  %xmm1,%xmm0
addsd  0x19b5(%rip),%xmm1
mov    0x10(%rsp),%rbx
lea    -0x8(%rbx),%eax
ucomisd %xmm1,%xmm0
cvttsd2si %xmm0,%ecx
cmovbe %eax,%ecx
mov    %ecx,0x4c(%rsp)
mov    (%rsp),%rsi
test   %esi,%esi
jle    195d <subspace+0x74d>
lea    0x1(%rsi),%r12d
mov    %esi,%r15d
lea    0x1(%r15),%r9
movapd %xmm6,%xmm0
unpcklpd %xmm6,%xmm0
mov    %r15,%r11
not    %r11
add    $0xfffffffffffffffc,%r15
mov    $0x1,%r10d
mov    $0x7,%r14d
xor    %r13d,%r13d
mov    %rbp,%rbx
mov    %r11,0x20(%rsp)
jmp    16c9 <subspace+0x4b9>
nopl   0x0(%rax)
add    $0x1,%r10
add    $0x1,%r13
add    $0x1,%r14
add    $0xffffffffffffffff,%r15
cmp    %r9,%r10
je     18c8 <subspace+0x6b8>
mov    %r13,%rdi
not    %rdi
lea    (%rdi,%r9,1),%rcx
mov    0x40(%rsp),%rax
mov    (%rax,%r10,8),%rbp
mov    0x38(%rsp),%rax
mov    (%rax,%r10,8),%rax
mov    %r10,%rdx
cmp    $0x4,%rcx
jb     1850 <subspace+0x640>
lea    (%rax,%r10,8),%rsi
lea    0x0(,%r9,8),%rbx
add    %rbp,%rbx
cmp    %rbx,%rsi
jae    172d <subspace+0x51d>
lea    (%rax,%r9,8),%r8
lea    0x0(,%r10,8),%rbx
add    %rbp,%rbx
mov    %r10,%rdx
cmp    %r8,%rbx
mov    0x328(%rsp),%rbx
mov    (%rsp),%rsi
jb     1850 <subspace+0x640>
lea    (%rdi,%r9,1),%rsi
add    $0xfffffffffffffffc,%rsi
mov    %rsi,%rbx
shr    $0x2,%rbx
add    $0x1,%rbx
cmp    $0x4,%rsi
jae    174d <subspace+0x53d>
xor    %edi,%edi
jmp    17eb <subspace+0x5db>
mov    %r15,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
and    $0xfffffffffffffffe,%rsi
lea    (%rax,%r14,8),%r8
lea    0x0(,%r14,8),%r11
add    %rbp,%r11
xor    %edi,%edi
nopl   (%rax)
movupd -0x30(%r11,%rdi,8),%xmm1
movupd -0x20(%r11,%rdi,8),%xmm2
mulpd  %xmm0,%xmm1
movupd -0x30(%r8,%rdi,8),%xmm3
addpd  %xmm1,%xmm3
movupd -0x20(%r8,%rdi,8),%xmm1
movupd -0x10(%r8,%rdi,8),%xmm4
movupd (%r8,%rdi,8),%xmm5
mulpd  %xmm0,%xmm2
addpd  %xmm1,%xmm2
movupd %xmm3,-0x30(%r8,%rdi,8)
movupd %xmm2,-0x20(%r8,%rdi,8)
movupd -0x10(%r11,%rdi,8),%xmm1
movupd (%r11,%rdi,8),%xmm2
mulpd  %xmm0,%xmm1
addpd  %xmm4,%xmm1
mulpd  %xmm0,%xmm2
addpd  %xmm5,%xmm2
movupd %xmm1,-0x10(%r8,%rdi,8)
movupd %xmm2,(%r8,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rsi
jne    1770 <subspace+0x560>
mov    %rcx,%rdx
and    $0xfffffffffffffffc,%rdx
test   $0x1,%bl
mov    (%rsp),%rsi
je     1830 <subspace+0x620>
add    %r10,%rdi
movupd 0x0(%rbp,%rdi,8),%xmm1
movupd 0x10(%rbp,%rdi,8),%xmm2
movupd (%rax,%rdi,8),%xmm3
movupd 0x10(%rax,%rdi,8),%xmm4
mulpd  %xmm0,%xmm1
addpd  %xmm3,%xmm1
mulpd  %xmm0,%xmm2
addpd  %xmm4,%xmm2
movupd %xmm1,(%rax,%rdi,8)
movupd %xmm2,0x10(%rax,%rdi,8)
cmp    %rdx,%rcx
mov    0x20(%rsp),%r11
mov    0x328(%rsp),%rbx
je     16b0 <subspace+0x4a0>
add    %r10,%rdx
nopl   0x0(%rax)
mov    %r9d,%ecx
sub    %edx,%ecx
mov    %rdx,%rdi
test   $0x1,%cl
je     1875 <subspace+0x665>
movsd  0x0(%rbp,%rdx,8),%xmm1
mulsd  %xmm6,%xmm1
addsd  (%rax,%rdx,8),%xmm1
movsd  %xmm1,(%rax,%rdx,8)
lea    0x1(%rdx),%rdi
not    %rdx
cmp    %r11,%rdx
je     16b0 <subspace+0x4a0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rdi,8),%xmm1
mulsd  %xmm6,%xmm1
addsd  (%rax,%rdi,8),%xmm1
movsd  %xmm1,(%rax,%rdi,8)
movsd  0x8(%rbp,%rdi,8),%xmm1
mulsd  %xmm6,%xmm1
addsd  0x8(%rax,%rdi,8),%xmm1
movsd  %xmm1,0x8(%rax,%rdi,8)
add    $0x2,%rdi
cmp    %rdi,%r9
jne    1890 <subspace+0x680>
jmp    16b0 <subspace+0x4a0>
mov    0x38(%rsp),%rbp
mov    %rbp,%rdi
mov    0x70(%rsp),%rdx
mov    0x30(%rsp),%r13
mov    %r13,%rcx
mov    %r13,%r8
mov    $0x1,%r9d
push   %rbx
push   $0x0
call   1090 <ldl_dcmp@plt>
mov    0x10(%rsp),%rcx
add    $0x10,%rsp
test   %ecx,%ecx
jle    198b <subspace+0x77b>
lea    0x1(%rcx),%esi
mov    $0x1,%eax
xorpd  %xmm0,%xmm0
mov    0x10(%rsp),%rbx
mov    0x8(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x40(%rsp),%rdx
mov    (%rdx,%rax,8),%rdx
movsd  (%rdx,%rax,8),%xmm2
ucomisd %xmm2,%xmm0
jae    25d4 <subspace+0x13c4>
mov    0x0(%rbp,%rax,8),%rdx
movsd  (%rdx,%rax,8),%xmm1
divsd  %xmm2,%xmm1
movsd  %xmm1,(%rdi,%rax,8)
add    $0x1,%rax
cmp    %rax,%rsi
jne    1920 <subspace+0x710>
test   %ebx,%ebx
jg     199d <subspace+0x78d>
jmp    1dbc <subspace+0xbac>
mov    0x38(%rsp),%rdi
mov    0x70(%rsp),%rdx
mov    0x30(%rsp),%r13
mov    %r13,%rcx
mov    %r13,%r8
mov    $0x1,%r9d
push   %rbp
push   $0x0
call   1090 <ldl_dcmp@plt>
mov    0x10(%rsp),%rcx
add    $0x10,%rsp
jmp    1990 <subspace+0x780>
mov    0x10(%rsp),%rbx
mov    0x8(%rsp),%rdi
test   %ebx,%ebx
jle    1dbc <subspace+0xbac>
movsd  0x8(%rdi),%xmm0
lea    0x1(%rcx),%r14d
lea    0x1(%rbx),%esi
xorpd  %xmm1,%xmm1
mov    $0xffffffff,%r13d
mov    $0x1,%r9d
mov    $0xfffffffffffffff7,%rbp
xor    %eax,%eax
xor    %r10d,%r10d
mov    0x328(%rsp),%rbx
mov    %rsi,0x20(%rsp)
jmp    1a19 <subspace+0x809>
mov    (%rsp),%rcx
mov    0x8(%rsp),%rdi
lea    0x1(%r8),%edx
mov    0x18(%rsp),%rsi
mov    %edx,(%rsi,%r9,4)
movslq %r8d,%rdx
movsd  0x8(%rdi,%rdx,8),%xmm2
add    $0x1,%r9
add    $0x1,%r13d
add    $0x1,%r10
add    $0xffffffffffffffff,%rax
add    $0x1,%rbp
movapd %xmm2,%xmm1
mov    0x20(%rsp),%rsi
cmp    %rsi,%r9
je     1d03 <subspace+0xaf3>
mov    %r13d,%r11d
add    $0x2,%r11
test   %ecx,%ecx
jle    1b10 <subspace+0x900>
mov    %rbp,%r15
mov    $0x1,%ebp
movapd %xmm0,%xmm2
mov    0x18(%rsp),%rsi
jmp    1a55 <subspace+0x845>
nopl   0x0(%rax,%rax,1)
mov    %ebp,(%rsi,%r9,4)
movapd %xmm3,%xmm2
add    $0x1,%rbp
cmp    %r14,%rbp
je     1b00 <subspace+0x8f0>
movsd  (%rdi,%rbp,8),%xmm3
ucomisd %xmm1,%xmm3
jb     1a48 <subspace+0x838>
ucomisd %xmm3,%xmm2
jb     1a48 <subspace+0x838>
movl   $0x1,(%rbx)
mov    $0x1,%r12d
cmp    $0x2,%r9
jb     1a40 <subspace+0x830>
mov    $0x1,%edx
xor    %edi,%edi
add    $0x1,%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    -0x4(%rsi,%rdx,4),%ebx
cmp    %rbx,%rbp
je     1ab0 <subspace+0x8a0>
lea    (%rax,%rdx,1),%rbx
add    $0x1,%rbx
add    $0x1,%rdx
cmp    $0x2,%rbx
jne    1a90 <subspace+0x880>
jmp    1ae0 <subspace+0x8d0>
nopl   (%rax)
mov    0x328(%rsp),%rdi
movl   $0x0,(%rdi)
lea    (%rax,%rdx,1),%rbx
mov    $0x1,%dil
cmp    $0x1,%rbx
jne    1a7f <subspace+0x86f>
mov    %r11d,%r12d
mov    0x8(%rsp),%rdi
mov    0x328(%rsp),%rbx
jmp    1a48 <subspace+0x838>
mov    %r11d,%r12d
test   $0x1,%dil
mov    0x8(%rsp),%rdi
mov    0x328(%rsp),%rbx
je     1a40 <subspace+0x830>
jmp    1a48 <subspace+0x838>
nop
mov    %r14d,%r8d
mov    %r15,%rbp
jmp    1b1a <subspace+0x90a>
nopl   0x0(%rax,%rax,1)
mov    $0x1,%r8d
movapd %xmm0,%xmm2
mov    0x18(%rsp),%rdx
cmpl   $0x0,(%rdx,%r9,4)
jne    19f3 <subspace+0x7e3>
mov    %rbp,%rdx
shr    $0x3,%rdx
lea    -0x9(%r10),%rdi
add    $0x1,%rdx
mov    %rdi,%rsi
shr    $0x3,%rsi
and    $0xfffffffffffffffe,%rdx
add    $0x1,%rsi
lea    -0x1(%r10),%r15
mov    0x18(%rsp),%rcx
mov    0x4(%rcx),%r8d
mov    $0x1,%r12d
cmp    $0x2,%r9
jb     19d4 <subspace+0x7c4>
jne    1b75 <subspace+0x965>
mov    (%rsp),%rcx
mov    0x8(%rsp),%rdi
jmp    1cf3 <subspace+0xae3>
mov    $0x2,%ebx
cmp    $0x8,%r15
jae    1b8e <subspace+0x97e>
mov    (%rsp),%rcx
mov    0x8(%rsp),%rdi
jmp    1cd2 <subspace+0xac2>
mov    %rsi,%r12
movd   %r8d,%xmm1
pshufd $0x0,%xmm1,%xmm1
xor    %ecx,%ecx
movdqa %xmm1,%xmm2
cmp    $0x8,%rdi
jae    1bb3 <subspace+0x9a3>
mov    0x18(%rsp),%rsi
mov    0x8(%rsp),%rdi
jmp    1c32 <subspace+0xa22>
mov    0x18(%rsp),%rsi
mov    0x8(%rsp),%rdi
nopl   (%rax)
movdqu 0x8(%rsi,%rcx,4),%xmm3
movdqu 0x18(%rsi,%rcx,4),%xmm4
movdqu 0x28(%rsi,%rcx,4),%xmm5
movdqu 0x38(%rsi,%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,%rdx
jne    1bc0 <subspace+0x9b0>
mov    %r15,%rbx
and    $0xfffffffffffffff8,%rbx
test   $0x1,%r12b
je     1c7a <subspace+0xa6a>
shl    $0x2,%rcx
or     $0x8,%rcx
movdqu (%rsi,%rcx,1),%xmm3
movdqu 0x10(%rsi,%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,%r8d
cmp    %rbx,%r15
mov    (%rsp),%rcx
je     1cf3 <subspace+0xae3>
or     $0x2,%rbx
mov    0x18(%rsp),%rsi
nopw   0x0(%rax,%rax,1)
mov    (%rsi,%rbx,4),%edx
cmp    %edx,%r8d
cmovl  %edx,%r8d
add    $0x1,%rbx
cmp    %rbx,%r9
jne    1ce0 <subspace+0xad0>
mov    %r11d,%r12d
mov    0x328(%rsp),%rbx
jmp    19dd <subspace+0x7cd>
mov    0x10(%rsp),%rbx
test   %ebx,%ebx
mov    0x50(%rsp),%rdi
mov    0x30(%rsp),%r13
jle    1dbc <subspace+0xbac>
mov    $0x1,%eax
lea    0x147e(%rip),%r9
lea    0x148f(%rip),%r10
movabs $0x3fc999999999999a,%rcx
99 c9 3f
mov    0x18(%rsp),%rbx
jmp    1d6f <subspace+0xb5f>
xchg   %ax,%ax
mov    0x18(%rsp),%rbx
mov    (%rbx,%rax,4),%edx
lea    (%rdx,%r8,1),%ebp
movslq %ebp,%rbp
mov    (%rdi,%rbp,8),%rbp
mov    %rcx,0x0(%rbp,%rax,8)
add    %r12d,%edx
movslq %edx,%rdx
mov    (%rdi,%rdx,8),%rdx
mov    %rcx,(%rdx,%rax,8)
add    $0x1,%rax
cmp    %rax,%rsi
je     1dc1 <subspace+0xbb1>
movslq (%rbx,%rax,4),%rbp
mov    (%rdi,%rbp,8),%rbx
movabs $0x3ff0000000000000,%rdx
mov    %rdx,(%rbx,%rax,8)
imul   $0x2aaaaaab,%rbp,%rbx
mov    %rbx,%rdx
shr    $0x3f,%rdx
shr    $0x20,%rbx
add    %edx,%ebx
add    %ebx,%ebx
lea    (%rbx,%rbx,2),%edx
sub    %edx,%ebp
mov    0x328(%rsp),%rdx
mov    %ebp,(%rdx)
cmp    $0x5,%ebp
ja     1d40 <subspace+0xb30>
movslq %ebp,%rdx
mov    (%r9,%rdx,4),%r8d
mov    (%r10,%rdx,4),%r12d
jmp    1d40 <subspace+0xb30>
lea    0x1(%rbx),%esi
jmp    1dc5 <subspace+0xbb5>
mov    (%rsp),%rcx
mov    0x320(%rsp),%rax
movl   $0x0,(%rax)
movslq 0x4c(%rsp),%rax
mov    %rax,0xa0(%rsp)
lea    0x1(%rcx),%eax
mov    %esi,%r12d
lea    -0x1(%rax),%rdx
lea    -0x2(%rax),%rsi
mov    %rsi,0xd0(%rsp)
mov    %edx,%ebp
and    $0x3,%ebp
mov    %rdx,0xb0(%rsp)
and    $0xfffffffffffffffc,%rdx
mov    %rdx,0xc8(%rsp)
xorpd  %xmm1,%xmm1
mov    %r12,0x30(%rsp)
mov    %rax,0x98(%rsp)
mov    %rbp,0xd8(%rsp)
nopl   0x0(%rax,%rax,1)
movsd  %xmm1,0xc0(%rsp)
cmpl   $0x0,0x10(%rsp)
jle    1fd0 <subspace+0xdc0>
mov    $0x1,%r8d
jmp    1e5d <subspace+0xc4d>
nopl   0x0(%rax)
add    $0x1,%r8
cmp    %r12,%r8
je     1fd0 <subspace+0xdc0>
mov    0x40(%rsp),%rdi
mov    0x50(%rsp),%rsi
mov    %r13,%rdx
mov    %rcx,%rbx
mov    %r8,0x20(%rsp)
call   1030 <prodABj@plt>
mov    0x38(%rsp),%rbp
mov    %rbp,%rdi
mov    %ebx,%esi
mov    0x70(%rsp),%r15
mov    %r15,%rdx
mov    %r13,%rcx
mov    %r13,%r12
mov    0x8(%rsp),%r13
mov    %r13,%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,0x78(%rsp)
lea    0x78(%rsp),%r14
nopl   0x0(%rax,%rax,1)
sub    $0x8,%rsp
mov    %rbp,%rdi
mov    0x8(%rsp),%rsi
mov    %r15,%rdx
mov    %r12,%rcx
mov    %r13,%r8
mov    %r14,%r9
push   %rbx
call   1060 <ldl_mprove@plt>
add    $0x10,%rsp
cmpl   $0x0,(%rbx)
jne    1ed0 <subspace+0xcc0>
mov    (%rsp),%rcx
test   %ecx,%ecx
mov    %r12,%r13
mov    0x30(%rsp),%r12
mov    0xd8(%rsp),%rbp
mov    0x20(%rsp),%r8
jle    1e50 <subspace+0xc40>
mov    $0x1,%eax
cmpq   $0x3,0xd0(%rsp)
jb     1f91 <subspace+0xd81>
xor    %eax,%eax
mov    0x28(%rsp),%rsi
mov    0x8(%rsp),%rdi
mov    0xc8(%rsp),%rbx
nopl   0x0(%rax)
movsd  0x8(%rdi,%rax,8),%xmm0
mov    0x8(%rsi,%rax,8),%rdx
movsd  %xmm0,(%rdx,%r8,8)
movsd  0x10(%rdi,%rax,8),%xmm0
mov    0x10(%rsi,%rax,8),%rdx
movsd  %xmm0,(%rdx,%r8,8)
movsd  0x18(%rdi,%rax,8),%xmm0
mov    0x18(%rsi,%rax,8),%rdx
movsd  %xmm0,(%rdx,%r8,8)
movsd  0x20(%rdi,%rax,8),%xmm0
mov    0x20(%rsi,%rax,8),%rdx
movsd  %xmm0,(%rdx,%r8,8)
add    $0x4,%rax
cmp    %rax,%rbx
jne    1f40 <subspace+0xd30>
add    $0x1,%rax
test   %rbp,%rbp
je     1e50 <subspace+0xc40>
mov    0x28(%rsp),%rdx
lea    (%rdx,%rax,8),%rdi
mov    0x8(%rsp),%rdx
lea    (%rdx,%rax,8),%rax
xor    %edx,%edx
xchg   %ax,%ax
movsd  (%rax,%rdx,8),%xmm0
mov    (%rdi,%rdx,8),%rsi
movsd  %xmm0,(%rsi,%r8,8)
add    $0x1,%rdx
cmp    %rdx,%rbp
jne    1fb0 <subspace+0xda0>
jmp    1e50 <subspace+0xc40>
nopl   (%rax)
mov    0x38(%rsp),%rdi
mov    0x28(%rsp),%r14
mov    %r14,%rsi
mov    0xa8(%rsp),%r15
mov    %r15,%rdx
mov    0x10(%rsp),%rbx
mov    %ebx,%r8d
call   1050 <xtAx@plt>
mov    0x40(%rsp),%rdi
mov    %r14,%rsi
mov    0x68(%rsp),%r14
mov    %r14,%rdx
mov    (%rsp),%rcx
mov    %ebx,%r8d
call   1050 <xtAx@plt>
mov    %r15,%rdi
mov    %r14,%rsi
mov    0xb8(%rsp),%r14
mov    %r14,%rdx
mov    0x60(%rsp),%r15
mov    %r15,%rcx
mov    %ebx,%r8d
call   1040 <jacobi@plt>
mov    0x28(%rsp),%rdi
mov    %r15,%rsi
mov    0x50(%rsp),%r15
mov    %r15,%rdx
mov    (%rsp),%rcx
mov    %ebx,%r8d
mov    %ebx,%r9d
call   10d0 <prodAB@plt>
mov    %r14,%rdi
mov    %r15,%rsi
mov    (%rsp),%rdx
mov    %ebx,%ecx
call   1130 <eigsort@plt>
mov    0xa0(%rsp),%rax
movsd  (%r14,%rax,8),%xmm1
ucomisd 0xfa0(%rip),%xmm1
jne    2080 <subspace+0xe70>
jnp    2586 <subspace+0x1376>
movapd %xmm1,%xmm0
subsd  0xc0(%rsp),%xmm0
andpd  0xf8b(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x78(%rsp)
mov    0x320(%rsp),%rcx
mov    (%rcx),%eax
lea    0x1(%rax),%edx
mov    %edx,(%rcx)
cmp    $0x3e8,%eax
movdqa 0x80(%rsp),%xmm7
jge    25a3 <subspace+0x1393>
ucomisd 0x58(%rsp),%xmm0
mov    (%rsp),%rcx
ja     1e30 <subspace+0xc20>
cmpl   $0x0,0x10(%rsp)
jle    225c <subspace+0x104c>
lea    -0x1(%r12),%rcx
mov    $0x1,%eax
cmp    $0x4,%rcx
jb     2190 <subspace+0xf80>
mov    %rcx,%rsi
and    $0xfffffffffffffffc,%rsi
lea    0x1(%rsi),%rax
movdqa %xmm7,%xmm8
punpcklqdq %xmm7,%xmm8
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movupd 0x8(%r14,%rdi,8),%xmm2
movupd 0x18(%r14,%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(%r14,%rdi,8)
movupd %xmm5,0x18(%r14,%rdi,8)
add    $0x4,%rdi
cmp    %rdi,%rsi
jne    2110 <subspace+0xf00>
cmp    %rsi,%rcx
je     21c6 <subspace+0xfb6>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%r14,%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,(%r14,%rax,8)
add    $0x1,%rax
cmp    %rax,%r12
jne    2190 <subspace+0xf80>
cmpl   $0x0,0x330(%rsp)
je     227d <subspace+0x106d>
mov    0x2e05(%rip),%r13
mov    0x0(%r13),%edi
lea    0xf70(%rip),%rsi
mov    $0x1,%al
call   1080 <fprintf@plt>
cmpl   $0x0,0x10(%rsp)
jle    227d <subspace+0x106d>
mov    $0x1,%ebx
lea    0xf7d(%rip),%r15
jmp    2239 <subspace+0x1029>
cs nopw 0x0(%rax,%rax,1)
call   1100 <sqrt@plt>
divsd  0xdf3(%rip),%xmm0
mov    %ebp,%edi
mov    %r15,%rsi
mov    %ebx,%edx
mov    %r12d,%ecx
mov    $0x1,%al
call   1080 <fprintf@plt>
add    $0x1,%rbx
cmp    %rbx,0x30(%rsp)
je     227d <subspace+0x106d>
mov    0x0(%r13),%ebp
mov    0x18(%rsp),%rax
mov    (%rax,%rbx,4),%r12d
movsd  (%r14,%rbx,8),%xmm0
ucomisd 0xdc4(%rip),%xmm0
jb     2210 <subspace+0x1000>
sqrtsd %xmm0,%xmm0
jmp    2215 <subspace+0x1005>
cmpl   $0x0,0x330(%rsp)
je     227d <subspace+0x106d>
mov    0x2d73(%rip),%rax
mov    (%rax),%edi
lea    0xee0(%rip),%rsi
mov    $0x1,%al
call   1080 <fprintf@plt>
movsd  0x58(%rsp),%xmm1
mov    0xa0(%rsp),%rax
addsd  (%r14,%rax,8),%xmm1
mov    0x38(%rsp),%r13
mov    %r13,%rdi
mov    0x40(%rsp),%rsi
mov    (%rsp),%rbx
mov    %ebx,%edx
mov    0x10(%rsp),%r12
mov    %r12d,%ecx
movapd 0x80(%rsp),%xmm0
mov    0x330(%rsp),%r8d
call   10c0 <sturm@plt>
movdqa 0x80(%rsp),%xmm6
mov    0x328(%rsp),%rcx
mov    %eax,(%rcx)
test   %ebx,%ebx
mov    0x98(%rsp),%rdi
jle    2508 <subspace+0x12f8>
pxor   0xd43(%rip),%xmm6
pshufd $0x44,%xmm6,%xmm0
mov    %rdi,%r8
neg    %r8
lea    -0x5(%rdi),%r10
mov    $0x1,%esi
mov    $0x7,%r11d
xor    %r14d,%r14d
jmp    2329 <subspace+0x1119>
nopl   0x0(%rax)
add    $0x1,%rsi
add    $0x1,%r14
add    $0x1,%r11
add    $0xffffffffffffffff,%r10
cmp    %rdi,%rsi
je     2508 <subspace+0x12f8>
mov    %r14,%r15
not    %r15
add    %rdi,%r15
mov    0x40(%rsp),%rax
mov    (%rax,%rsi,8),%rbp
mov    0x0(%r13,%rsi,8),%rbx
mov    %rsi,%rdx
cmp    $0x4,%r15
jb     24a0 <subspace+0x1290>
lea    (%rbx,%rsi,8),%rax
lea    0x0(,%rdi,8),%rcx
add    %rbp,%rcx
cmp    %rcx,%rax
jae    237c <subspace+0x116c>
lea    (%rbx,%rdi,8),%rax
lea    0x0(,%rsi,8),%rcx
add    %rbp,%rcx
mov    %rsi,%rdx
cmp    %rax,%rcx
jb     24a0 <subspace+0x1290>
mov    0xb0(%rsp),%rax
sub    %r14,%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,%r9
shr    $0x2,%r9
add    $0x1,%r9
cmp    $0x4,%rax
jae    23a3 <subspace+0x1193>
xor    %ecx,%ecx
jmp    243f <subspace+0x122f>
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
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
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    23d0 <subspace+0x11c0>
mov    %r15,%rdx
and    $0xfffffffffffffffc,%rdx
test   $0x1,%r9b
mov    0x98(%rsp),%rdi
je     2489 <subspace+0x1279>
add    %rsi,%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     2310 <subspace+0x1100>
add    %rsi,%rdx
cs nopw 0x0(%rax,%rax,1)
nop
mov    %edi,%ecx
sub    %edx,%ecx
mov    %rdx,%rax
test   $0x1,%cl
je     24c4 <subspace+0x12b4>
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     2310 <subspace+0x1100>
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,%rdi
jne    24d0 <subspace+0x12c0>
jmp    2310 <subspace+0x1100>
mov    0xa8(%rsp),%rdi
mov    $0x1,%esi
mov    %r12d,%edx
mov    $0x1,%ecx
mov    %r12d,%r8d
call   10f0 <free_dmatrix@plt>
mov    0x68(%rsp),%rdi
mov    $0x1,%esi
mov    %r12d,%edx
mov    $0x1,%ecx
mov    %r12d,%r8d
call   10f0 <free_dmatrix@plt>
mov    0x28(%rsp),%rdi
mov    $0x1,%esi
mov    (%rsp),%rdx
mov    $0x1,%ecx
mov    %r12d,%r8d
call   10f0 <free_dmatrix@plt>
mov    0x60(%rsp),%rdi
mov    $0x1,%esi
mov    %r12d,%edx
mov    $0x1,%ecx
mov    %r12d,%r8d
call   10f0 <free_dmatrix@plt>
add    $0x2e8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xorps  %xmm0,%xmm0
cvtsi2sdl 0x4c(%rsp),%xmm0
lea    0xb54(%rip),%rsi
lea    0xe0(%rsp),%rbx
mov    %rbx,%rdi
jmp    25bb <subspace+0x13ab>
lea    0xb70(%rip),%rsi
lea    0xe0(%rsp),%rbx
mov    %rbx,%rdi
movsd  0x58(%rsp),%xmm1
mov    $0x2,%al
call   1110 <sprintf@plt>
mov    %rbx,%rdi
call   10a0 <errorMsg@plt>
mov    $0x20,%edi
call   1120 <exit@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
lea    0xaec(%rip),%rsi
lea    0xe0(%rsp),%rbx
mov    %rbx,%rdi
movapd %xmm0,%xmm1
mov    $0x3,%al
call   1110 <sprintf@plt>
jmp    25c2 <subspace+0x13b2>
xorps  %xmm1,%xmm1
cvtsi2sd %ebp,%xmm1
lea    0xa38(%rip),%rsi
lea    0xe0(%rsp),%rbx
mov    %rbx,%rdi
movsd  0x20(%rsp),%xmm0
jmp    25bb <subspace+0x13ab>

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

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