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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double **dmatrix(int, int, int, int);
double *dvector(int, int);
int /*<<< orphan*/ eigsort(double *, double **, int, int);
int /*<<< orphan*/ errorMsg(char *);
double fabs(double);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, ...);
int /*<<< orphan*/ free_dmatrix(double **, int, int, int, int);
int /*<<< orphan*/ free_dvector(double *, int, 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*/ sprintf(char *, char *, double, double);
double sqrt(double);
int /*<<< orphan*/ stdout;
int sturm(double **, double **, int, int, double, double, int);
double xtAy(double *, double **, double *, int, double *);
int stodola(double **K, double **M, int n, int m, double *w, double **V,
            double tol, double shift, int *iter, int *ok, int verbose) {
  double **D, d_min = 0.0, d_max = 0.0, d_old = 0.0, *d, *u, *v, *c, vMv, RQ,
              RQold = 0.0, error = 1.0;
  int i_ex = 9999, modes, disp = 0, i, j, k;
  char errMsg[512];
  D = dmatrix(1, n, 1, n);
  d = dvector(1, n);
  u = dvector(1, n);
  v = dvector(1, n);
  c = dvector(1, m);
  modes = (int)((double)(0.5 * m) > (double)(m - 8) ? (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);
  if (*ok < 0) {
    return 32;
  }
  for (j = 1; j <= n; j++) {
    for (i = 1; i <= n; i++)
      v[i] = M[i][j];
    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++)
      D[i][j] = d[i];
  }
  *iter = 0;
  for (i = 1; i <= n; i++)
    if (D[i][i] > d_max)
      d_max = D[i][i];
  d_old = d_min = d_max;
  for (i = 1; i <= n; i++)
    if (D[i][i] < d_min)
      d_min = D[i][i];
  for (k = 1; k <= m; k++) {
    d_max = d_min;
    for (i = 1; i <= n; i++) {
      u[i] = 0.0;
      if (D[i][i] < d_old && D[i][i] > d_max) {
        d_max = D[i][i];
        i_ex = i;
      }
    }
    u[i_ex] = 1.0;
    u[i_ex + 1] = 1.e-4;
    d_old = d_max;
    vMv = xtAy(u, M, u, n, d);
    for (i = 1; i <= n; i++)
      u[i] /= sqrt(vMv);
    for (j = 1; j < k; j++) {
      for (i = 1; i <= n; i++)
        v[i] = V[i][j];
      c[j] = xtAy(v, M, u, n, d);
    }
    for (j = 1; j < k; j++)
      for (i = 1; i <= n; i++)
        u[i] -= c[j] * V[i][j];
    vMv = xtAy(u, M, u, n, d);
    for (i = 1; i <= n; i++)
      u[i] /= sqrt(vMv);
    RQ = xtAy(u, K, u, n, d);
    do {
      for (i = 1; i <= n; i++) {
        v[i] = 0.0;
        for (j = 1; j <= n; j++)
          v[i] += D[i][j] * u[j];
      }
      vMv = xtAy(v, M, v, n, d);
      for (i = 1; i <= n; i++)
        v[i] /= sqrt(vMv);
      for (j = 1; j < k; j++) {
        for (i = 1; i <= n; i++)
          u[i] = V[i][j];
        c[j] = xtAy(u, M, v, n, d);
      }
      for (j = 1; j < k; j++)
        for (i = 1; i <= n; i++)
          v[i] -= c[j] * V[i][j];
      vMv = xtAy(v, M, v, n, d);
      for (i = 1; i <= n; i++)
        u[i] = v[i] / sqrt(vMv);
      RQold = RQ;
      RQ = xtAy(u, K, u, n, d);
      (*iter)++;
      if (*iter > 2000) {
        sprintf(errMsg,
                "  stodola: Iteration limit exceeded\n  rel. error = %e > %e\n",
                (fabs(RQ - RQold) / RQ), tol);
        errorMsg(errMsg);
        return 32;
      }
    } while ((fabs(RQ - RQold) / RQ) > tol);
    for (i = 1; i <= n; i++)
      V[i][k] = v[i];
    w[k] = xtAy(u, K, u, n, d);
    if (w[k] > shift)
      w[k] = w[k] - shift;
    else
      w[k] = shift - w[k];
    if (verbose) {
      fprintf(stdout, "  mode: %2d\tDoF: %5d\t", k, i_ex);
      fprintf(stdout, " %9.4f Hz\t iter: %4d   error: %.4e \n",
              sqrt(w[k]) /
                  (2.0 * 3.14159265358979323846264338327950288419716939937510),
              *iter, (fabs(RQ - RQold) / RQ));
    }
  }
  eigsort(w, V, n, m);
  *ok = sturm(K, M, n, m, shift, w[modes] + tol, verbose);
  free_dmatrix(D, 1, n, 1, n);
  free_dvector(d, 1, n);
  free_dvector(u, 1, n);
  free_dvector(v, 1, n);
  free_dvector(c, 1, m);
  return 0;
}


x86 assembly (clang, -O0):
<stodola>:
push   %rbp
mov    %rsp,%rbp
sub    $0x2f0,%rsp
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
mov    %ecx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movsd  %xmm0,-0x38(%rbp)
movsd  %xmm1,-0x40(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  0x1dd7(%rip),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movl   $0x270f,-0xa4(%rbp)
movl   $0x0,-0xac(%rbp)
mov    -0x1c(%rbp),%esi
mov    -0x1c(%rbp),%ecx
mov    $0x1,%edx
mov    %edx,%edi
call   1040 <dmatrix@plt>
mov    %rax,-0x48(%rbp)
mov    -0x1c(%rbp),%esi
mov    $0x1,%edi
call   1080 <dvector@plt>
mov    %rax,-0x68(%rbp)
mov    -0x1c(%rbp),%esi
mov    $0x1,%edi
call   1080 <dvector@plt>
mov    %rax,-0x70(%rbp)
mov    -0x1c(%rbp),%esi
mov    $0x1,%edi
call   1080 <dvector@plt>
mov    %rax,-0x78(%rbp)
mov    -0x20(%rbp),%esi
mov    $0x1,%edi
call   1080 <dvector@plt>
mov    %rax,-0x80(%rbp)
cvtsi2sdl -0x20(%rbp),%xmm1
movsd  0x1d4c(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%eax
sub    $0x8,%eax
cvtsi2sd %eax,%xmm1
ucomisd %xmm1,%xmm0
jbe    12ec <stodola+0x11c>
cvtsi2sdl -0x20(%rbp),%xmm0
movsd  0x1d37(%rip),%xmm1
divsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x2c4(%rbp)
jmp    12f8 <stodola+0x128>
mov    -0x20(%rbp),%eax
sub    $0x8,%eax
mov    %eax,-0x2c4(%rbp)
mov    -0x2c4(%rbp),%eax
mov    %eax,-0xa8(%rbp)
movl   $0x1,-0xb0(%rbp)
mov    -0xb0(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     13ad <stodola+0x1dd>
mov    -0xb0(%rbp),%eax
mov    %eax,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1394 <stodola+0x1c4>
movsd  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0xb0(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xb4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
movslq -0xb0(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xb4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    1329 <stodola+0x159>
jmp    1399 <stodola+0x1c9>
mov    -0xb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
jmp    130e <stodola+0x13e>
mov    -0x10(%rbp),%rdi
mov    -0x1c(%rbp),%esi
mov    -0x70(%rbp),%rdx
mov    -0x78(%rbp),%rcx
mov    -0x78(%rbp),%r8
mov    0x18(%rbp),%rax
mov    $0x1,%r9d
xor    %r10d,%r10d
movl   $0x0,(%rsp)
mov    %rax,0x8(%rsp)
call   1060 <ldl_dcmp@plt>
mov    0x18(%rbp),%rax
cmpl   $0x0,(%rax)
jge    13f7 <stodola+0x227>
movl   $0x20,-0x4(%rbp)
jmp    20c7 <stodola+0xef7>
movl   $0x1,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     15cb <stodola+0x3fb>
movl   $0x1,-0xb0(%rbp)
mov    -0xb0(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1468 <stodola+0x298>
mov    -0x18(%rbp),%rax
movslq -0xb0(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xb4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x78(%rbp),%rax
movslq -0xb0(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
jmp    141a <stodola+0x24a>
mov    -0x10(%rbp),%rdi
mov    -0x1c(%rbp),%esi
mov    -0x70(%rbp),%rdx
mov    -0x78(%rbp),%rcx
mov    -0x68(%rbp),%r8
mov    0x18(%rbp),%rax
xor    %r9d,%r9d
movl   $0x1,(%rsp)
mov    %rax,0x8(%rsp)
call   1060 <ldl_dcmp@plt>
cmpl   $0x0,-0xac(%rbp)
je     14b7 <stodola+0x2e7>
mov    0x3b39(%rip),%rax
mov    (%rax),%edi
lea    0x1b90(%rip),%rsi
mov    $0x0,%al
call   1050 <fprintf@plt>
mov    0x18(%rbp),%rax
movl   $0x1,(%rax)
movsd  0x1b3f(%rip),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x10(%rbp),%rdi
mov    -0x1c(%rbp),%esi
mov    -0x70(%rbp),%rdx
mov    -0x78(%rbp),%rcx
mov    -0x68(%rbp),%r8
mov    0x18(%rbp),%rax
lea    -0xa0(%rbp),%r9
mov    %rax,(%rsp)
call   1030 <ldl_mprove@plt>
cmpl   $0x0,-0xac(%rbp)
je     1524 <stodola+0x354>
mov    0x3ad4(%rip),%rax
mov    (%rax),%edi
movsd  -0xa0(%rbp),%xmm0
ff
lea    0x1b37(%rip),%rsi
mov    $0x1,%al
call   1050 <fprintf@plt>
jmp    1529 <stodola+0x359>
mov    0x18(%rbp),%rax
cmpl   $0x0,(%rax)
jne    14d1 <stodola+0x301>
cmpl   $0x0,-0xac(%rbp)
je     155a <stodola+0x38a>
mov    0x3a96(%rip),%rax
mov    (%rax),%edi
lea    0x1b7c(%rip),%rsi
mov    $0x0,%al
call   1050 <fprintf@plt>
movl   $0x1,-0xb0(%rbp)
mov    -0xb0(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     15b2 <stodola+0x3e2>
mov    -0x68(%rbp),%rax
movslq -0xb0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
movslq -0xb0(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xb4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
jmp    1564 <stodola+0x394>
jmp    15b7 <stodola+0x3e7>
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    1401 <stodola+0x231>
mov    0x10(%rbp),%rax
movl   $0x0,(%rax)
movl   $0x1,-0xb0(%rbp)
mov    -0xb0(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     164d <stodola+0x47d>
mov    -0x48(%rbp),%rax
movslq -0xb0(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xb0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0x58(%rbp),%xmm0
jbe    1634 <stodola+0x464>
mov    -0x48(%rbp),%rax
movslq -0xb0(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xb0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
jmp    1639 <stodola+0x469>
mov    -0xb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
jmp    15df <stodola+0x40f>
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  %xmm0,-0x60(%rbp)
movl   $0x1,-0xb0(%rbp)
mov    -0xb0(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     16d8 <stodola+0x508>
mov    -0x48(%rbp),%rax
movslq -0xb0(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xb0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x50(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    16bf <stodola+0x4ef>
mov    -0x48(%rbp),%rax
movslq -0xb0(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xb0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
jmp    16c4 <stodola+0x4f4>
mov    -0xb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
jmp    1666 <stodola+0x496>
movl   $0x1,-0xb8(%rbp)
mov    -0xb8(%rbp),%eax
cmp    -0x20(%rbp),%eax
jg     2018 <stodola+0xe48>
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x1,-0xb0(%rbp)
mov    -0xb0(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     17bc <stodola+0x5ec>
mov    -0x70(%rbp),%rax
movslq -0xb0(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%rax
movslq -0xb0(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xb0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x60(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    17a3 <stodola+0x5d3>
mov    -0x48(%rbp),%rax
movslq -0xb0(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xb0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0x58(%rbp),%xmm0
jbe    17a3 <stodola+0x5d3>
mov    -0x48(%rbp),%rax
movslq -0xb0(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xb0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0xb0(%rbp),%eax
mov    %eax,-0xa4(%rbp)
jmp    17a8 <stodola+0x5d8>
mov    -0xb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
jmp    1705 <stodola+0x535>
mov    -0x70(%rbp),%rax
movslq -0xa4(%rbp),%rcx
movsd  0x1839(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x70(%rbp),%rax
mov    -0xa4(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  0x182c(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x70(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x70(%rbp),%rdx
mov    -0x1c(%rbp),%ecx
mov    -0x68(%rbp),%r8
call   1090 <xtAy@plt>
movsd  %xmm0,-0x88(%rbp)
ff
movl   $0x1,-0xb0(%rbp)
mov    -0xb0(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1871 <stodola+0x6a1>
movsd  -0x88(%rbp),%xmm0
ff
call   10d0 <sqrt@plt>
movaps %xmm0,%xmm1
mov    -0x70(%rbp),%rax
movslq -0xb0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
jmp    1825 <stodola+0x655>
movl   $0x1,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
cmp    -0xb8(%rbp),%eax
jge    1921 <stodola+0x751>
movl   $0x1,-0xb0(%rbp)
mov    -0xb0(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     18e5 <stodola+0x715>
mov    -0x30(%rbp),%rax
movslq -0xb0(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xb4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x78(%rbp),%rax
movslq -0xb0(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
jmp    1897 <stodola+0x6c7>
mov    -0x78(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x70(%rbp),%rdx
mov    -0x1c(%rbp),%ecx
mov    -0x68(%rbp),%r8
call   1090 <xtAy@plt>
mov    -0x80(%rbp),%rax
movslq -0xb4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    187b <stodola+0x6ab>
movl   $0x1,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
cmp    -0xb8(%rbp),%eax
jge    19e2 <stodola+0x812>
movl   $0x1,-0xb0(%rbp)
mov    -0xb0(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     19c9 <stodola+0x7f9>
mov    -0x80(%rbp),%rax
movslq -0xb4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0xb0(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xb4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x70(%rbp),%rax
movslq -0xb0(%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    -0xb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
jmp    1947 <stodola+0x777>
jmp    19ce <stodola+0x7fe>
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    192b <stodola+0x75b>
mov    -0x70(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x70(%rbp),%rdx
mov    -0x1c(%rbp),%ecx
mov    -0x68(%rbp),%r8
call   1090 <xtAy@plt>
movsd  %xmm0,-0x88(%rbp)
ff
movl   $0x1,-0xb0(%rbp)
mov    -0xb0(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1a58 <stodola+0x888>
movsd  -0x88(%rbp),%xmm0
ff
call   10d0 <sqrt@plt>
movaps %xmm0,%xmm1
mov    -0x70(%rbp),%rax
movslq -0xb0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
jmp    1a0c <stodola+0x83c>
mov    -0x70(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x70(%rbp),%rdx
mov    -0x1c(%rbp),%ecx
mov    -0x68(%rbp),%r8
call   1090 <xtAy@plt>
movsd  %xmm0,-0x90(%rbp)
ff
movl   $0x1,-0xb0(%rbp)
mov    -0xb0(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1b32 <stodola+0x962>
mov    -0x78(%rbp),%rax
movslq -0xb0(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x1,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1b19 <stodola+0x949>
mov    -0x48(%rbp),%rax
movslq -0xb0(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xb4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x70(%rbp),%rax
movslq -0xb4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x78(%rbp),%rax
movslq -0xb0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    1aae <stodola+0x8de>
jmp    1b1e <stodola+0x94e>
mov    -0xb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
jmp    1a82 <stodola+0x8b2>
mov    -0x78(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x78(%rbp),%rdx
mov    -0x1c(%rbp),%ecx
mov    -0x68(%rbp),%r8
call   1090 <xtAy@plt>
movsd  %xmm0,-0x88(%rbp)
ff
movl   $0x1,-0xb0(%rbp)
mov    -0xb0(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1ba8 <stodola+0x9d8>
movsd  -0x88(%rbp),%xmm0
ff
call   10d0 <sqrt@plt>
movaps %xmm0,%xmm1
mov    -0x78(%rbp),%rax
movslq -0xb0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
jmp    1b5c <stodola+0x98c>
movl   $0x1,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
cmp    -0xb8(%rbp),%eax
jge    1c58 <stodola+0xa88>
movl   $0x1,-0xb0(%rbp)
mov    -0xb0(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1c1c <stodola+0xa4c>
mov    -0x30(%rbp),%rax
movslq -0xb0(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xb4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x70(%rbp),%rax
movslq -0xb0(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
jmp    1bce <stodola+0x9fe>
mov    -0x70(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x78(%rbp),%rdx
mov    -0x1c(%rbp),%ecx
mov    -0x68(%rbp),%r8
call   1090 <xtAy@plt>
mov    -0x80(%rbp),%rax
movslq -0xb4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    1bb2 <stodola+0x9e2>
movl   $0x1,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
cmp    -0xb8(%rbp),%eax
jge    1d19 <stodola+0xb49>
movl   $0x1,-0xb0(%rbp)
mov    -0xb0(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1d00 <stodola+0xb30>
mov    -0x80(%rbp),%rax
movslq -0xb4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0xb0(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xb4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x78(%rbp),%rax
movslq -0xb0(%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    -0xb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
jmp    1c7e <stodola+0xaae>
jmp    1d05 <stodola+0xb35>
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    1c62 <stodola+0xa92>
mov    -0x78(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x78(%rbp),%rdx
mov    -0x1c(%rbp),%ecx
mov    -0x68(%rbp),%r8
call   1090 <xtAy@plt>
movsd  %xmm0,-0x88(%rbp)
ff
movl   $0x1,-0xb0(%rbp)
mov    -0xb0(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1daa <stodola+0xbda>
mov    -0x78(%rbp),%rax
movslq -0xb0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x2d0(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
call   10d0 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0x2d0(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
mov    -0x70(%rbp),%rax
movslq -0xb0(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
jmp    1d43 <stodola+0xb73>
movsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x70(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x70(%rbp),%rdx
mov    -0x1c(%rbp),%ecx
mov    -0x68(%rbp),%r8
call   1090 <xtAy@plt>
movsd  %xmm0,-0x90(%rbp)
ff
mov    0x10(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
mov    0x10(%rbp),%rax
cmpl   $0x7d0,(%rax)
jle    1e48 <stodola+0xc78>
lea    -0x2c0(%rbp),%rdi
movsd  -0x90(%rbp),%xmm0
ff
subsd  -0x98(%rbp),%xmm0
ff
movaps 0x121d(%rip),%xmm1
pand   %xmm1,%xmm0
divsd  -0x90(%rbp),%xmm0
ff
movsd  -0x38(%rbp),%xmm1
lea    0x122f(%rip),%rsi
call   10e0 <sprintf@plt>
lea    -0x2c0(%rbp),%rdi
call   1070 <errorMsg@plt>
movl   $0x20,-0x4(%rbp)
jmp    20c7 <stodola+0xef7>
jmp    1e4d <stodola+0xc7d>
movsd  -0x90(%rbp),%xmm0
ff
subsd  -0x98(%rbp),%xmm0
ff
movaps 0x11cc(%rip),%xmm1
pand   %xmm1,%xmm0
divsd  -0x90(%rbp),%xmm0
ff
ucomisd -0x38(%rbp),%xmm0
ja     1a78 <stodola+0x8a8>
movl   $0x1,-0xb0(%rbp)
mov    -0xb0(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1ed3 <stodola+0xd03>
mov    -0x78(%rbp),%rax
movslq -0xb0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0xb0(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xb8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
jmp    1e85 <stodola+0xcb5>
mov    -0x70(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x70(%rbp),%rdx
mov    -0x1c(%rbp),%ecx
mov    -0x68(%rbp),%r8
call   1090 <xtAy@plt>
mov    -0x28(%rbp),%rax
movslq -0xb8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
movslq -0xb8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0x40(%rbp),%xmm0
jbe    1f40 <stodola+0xd70>
mov    -0x28(%rbp),%rax
movslq -0xb8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x40(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0xb8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1f65 <stodola+0xd95>
movsd  -0x40(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0xb8(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0xb8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x0,0x20(%rbp)
je     1fff <stodola+0xe2f>
mov    0x306a(%rip),%rax
mov    (%rax),%edi
mov    -0xb8(%rbp),%edx
mov    -0xa4(%rbp),%ecx
lea    0x110b(%rip),%rsi
mov    $0x0,%al
call   1050 <fprintf@plt>
mov    0x3047(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x2d4(%rbp)
mov    -0x28(%rbp),%rax
movslq -0xb8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   10d0 <sqrt@plt>
mov    -0x2d4(%rbp),%edi
movsd  0x105c(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    0x10(%rbp),%rax
mov    (%rax),%edx
movsd  -0x90(%rbp),%xmm1
ff
subsd  -0x98(%rbp),%xmm1
ff
movaps 0x104b(%rip),%xmm2
pand   %xmm2,%xmm1
divsd  -0x90(%rbp),%xmm1
ff
lea    0x10b4(%rip),%rsi
mov    $0x2,%al
call   1050 <fprintf@plt>
jmp    2004 <stodola+0xe34>
mov    -0xb8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb8(%rbp)
jmp    16e2 <stodola+0x512>
mov    -0x28(%rbp),%rdi
mov    -0x30(%rbp),%rsi
mov    -0x1c(%rbp),%edx
mov    -0x20(%rbp),%ecx
call   10f0 <eigsort@plt>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x1c(%rbp),%edx
mov    -0x20(%rbp),%ecx
movsd  -0x40(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0xa8(%rbp),%r8
movsd  (%rax,%r8,8),%xmm1
addsd  -0x38(%rbp),%xmm1
mov    0x20(%rbp),%r8d
call   10a0 <sturm@plt>
mov    %eax,%ecx
mov    0x18(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x48(%rbp),%rdi
mov    -0x1c(%rbp),%edx
mov    -0x1c(%rbp),%r8d
mov    $0x1,%ecx
mov    %ecx,%esi
call   10c0 <free_dmatrix@plt>
mov    -0x68(%rbp),%rdi
mov    -0x1c(%rbp),%edx
mov    $0x1,%esi
call   10b0 <free_dvector@plt>
mov    -0x70(%rbp),%rdi
mov    -0x1c(%rbp),%edx
mov    $0x1,%esi
call   10b0 <free_dvector@plt>
mov    -0x78(%rbp),%rdi
mov    -0x1c(%rbp),%edx
mov    $0x1,%esi
call   10b0 <free_dvector@plt>
mov    -0x80(%rbp),%rdi
mov    -0x20(%rbp),%edx
mov    $0x1,%esi
call   10b0 <free_dvector@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x2f0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<stodola>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x2f8,%rsp
movaps %xmm1,0xa0(%rsp)
movsd  %xmm0,0x78(%rsp)
mov    %r9,%r15
mov    %r8,0x68(%rsp)
mov    %ecx,%ebp
mov    %edx,%ebx
mov    %rsi,0x40(%rsp)
mov    %rdi,%r13
movabs $0x3ff0000000000000,%rax
mov    %rax,0x98(%rsp)
mov    $0x1,%edi
mov    %edx,%esi
mov    $0x1,%edx
mov    %ebx,%ecx
call   1040 <dmatrix@plt>
mov    %rax,0x50(%rsp)
mov    $0x1,%edi
mov    %ebx,%esi
call   1080 <dvector@plt>
mov    %rax,0x18(%rsp)
mov    $0x1,%edi
mov    %ebx,%esi
call   1080 <dvector@plt>
mov    %rax,%r12
mov    $0x1,%edi
mov    %ebx,%esi
call   1080 <dvector@plt>
mov    %rax,%r14
mov    $0x1,%edi
mov    %ebp,%esi
call   1080 <dvector@plt>
mov    %r13,%rdi
xorps  %xmm0,%xmm0
cvtsi2sd %ebp,%xmm0
mulsd  0x1d86(%rip),%xmm0
mov    %rax,0x88(%rsp)
mov    %rbp,0x70(%rsp)
lea    -0x8(%rbp),%eax
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
ucomisd %xmm1,%xmm0
movapd 0xa0(%rsp),%xmm6
cvttsd2si %xmm0,%ecx
cmovbe %eax,%ecx
test   %ebx,%ebx
mov    %rbx,0x20(%rsp)
mov    %r13,0x48(%rsp)
mov    %ecx,0x94(%rsp)
jle    174c <stodola+0x57c>
mov    %ebx,%ecx
lea    0x1(%rcx),%r9
movapd %xmm6,%xmm0
unpcklpd %xmm6,%xmm0
lea    -0x4(%rcx),%r10
mov    $0x1,%eax
mov    $0x7,%r11d
xor    %r13d,%r13d
mov    %rdi,%rbp
mov    %rcx,0x8(%rsp)
mov    %r9,0x10(%rsp)
jmp    1309 <stodola+0x139>
nopl   (%rax)
add    $0x1,%rax
add    $0x1,%r13
add    $0x1,%r11
add    $0xffffffffffffffff,%r10
cmp    %r9,%rax
je     14d9 <stodola+0x309>
mov    %r13,%rdx
not    %rdx
lea    (%rdx,%r9,1),%rdi
mov    0x40(%rsp),%rcx
mov    (%rcx,%rax,8),%r8
mov    0x0(%rbp,%rax,8),%rbx
mov    %rax,%rcx
cmp    $0x4,%rdi
jb     1460 <stodola+0x290>
lea    (%rbx,%rax,8),%rcx
lea    (%r8,%r9,8),%rsi
cmp    %rsi,%rcx
jae    1354 <stodola+0x184>
lea    (%rbx,%r9,8),%rsi
lea    (%r8,%rax,8),%rbp
mov    %rax,%rcx
cmp    %rsi,%rbp
mov    0x48(%rsp),%rbp
jb     1460 <stodola+0x290>
lea    (%rdx,%r9,1),%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,%r9
shr    $0x2,%r9
add    $0x1,%r9
cmp    $0x4,%rcx
jae    1374 <stodola+0x1a4>
xor    %ebp,%ebp
jmp    13ff <stodola+0x22f>
mov    %r10,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
and    $0xfffffffffffffffe,%rcx
lea    (%rbx,%r11,8),%rdx
lea    (%r8,%r11,8),%rsi
xor    %ebp,%ebp
nopl   (%rax)
movupd -0x30(%rsi,%rbp,8),%xmm1
movupd -0x20(%rsi,%rbp,8),%xmm2
mulpd  %xmm0,%xmm1
movupd -0x30(%rdx,%rbp,8),%xmm3
addpd  %xmm1,%xmm3
movupd -0x20(%rdx,%rbp,8),%xmm1
movupd -0x10(%rdx,%rbp,8),%xmm4
movupd (%rdx,%rbp,8),%xmm5
mulpd  %xmm0,%xmm2
addpd  %xmm1,%xmm2
movupd %xmm3,-0x30(%rdx,%rbp,8)
movupd %xmm2,-0x20(%rdx,%rbp,8)
movupd -0x10(%rsi,%rbp,8),%xmm1
movupd (%rsi,%rbp,8),%xmm2
mulpd  %xmm0,%xmm1
addpd  %xmm4,%xmm1
mulpd  %xmm0,%xmm2
addpd  %xmm5,%xmm2
movupd %xmm1,-0x10(%rdx,%rbp,8)
movupd %xmm2,(%rdx,%rbp,8)
add    $0x8,%rbp
add    $0xfffffffffffffffe,%rcx
jne    1390 <stodola+0x1c0>
mov    %rdi,%rcx
and    $0xfffffffffffffffc,%rcx
test   $0x1,%r9b
je     1442 <stodola+0x272>
add    %rax,%rbp
movupd (%r8,%rbp,8),%xmm1
movupd 0x10(%r8,%rbp,8),%xmm2
movupd (%rbx,%rbp,8),%xmm3
movupd 0x10(%rbx,%rbp,8),%xmm4
mulpd  %xmm0,%xmm1
addpd  %xmm3,%xmm1
mulpd  %xmm0,%xmm2
addpd  %xmm4,%xmm2
movupd %xmm1,(%rbx,%rbp,8)
movupd %xmm2,0x10(%rbx,%rbp,8)
cmp    %rcx,%rdi
mov    0x48(%rsp),%rbp
mov    0x10(%rsp),%r9
je     12f0 <stodola+0x120>
add    %rax,%rcx
nopl   0x0(%rax,%rax,1)
mov    %r9d,%esi
sub    %ecx,%esi
mov    %rcx,%rdx
test   $0x1,%sil
je     1486 <stodola+0x2b6>
movsd  (%r8,%rcx,8),%xmm1
mulsd  %xmm6,%xmm1
addsd  (%rbx,%rcx,8),%xmm1
movsd  %xmm1,(%rbx,%rcx,8)
lea    0x1(%rcx),%rdx
cmp    %rcx,0x8(%rsp)
je     12f0 <stodola+0x120>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r8,%rdx,8),%xmm1
mulsd  %xmm6,%xmm1
addsd  (%rbx,%rdx,8),%xmm1
movsd  %xmm1,(%rbx,%rdx,8)
movsd  0x8(%r8,%rdx,8),%xmm1
mulsd  %xmm6,%xmm1
addsd  0x8(%rbx,%rdx,8),%xmm1
movsd  %xmm1,0x8(%rbx,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%r9
jne    14a0 <stodola+0x2d0>
jmp    12f0 <stodola+0x120>
mov    %rbp,%rdi
mov    0x20(%rsp),%rbx
mov    %ebx,%esi
mov    %r12,%rdx
mov    %r14,%rcx
mov    %r14,%r8
mov    $0x1,%r9d
mov    0x338(%rsp),%rbp
push   %rbp
push   $0x0
call   1060 <ldl_dcmp@plt>
add    $0x10,%rsp
cmpl   $0x0,0x0(%rbp)
js     258f <stodola+0x13bf>
mov    %rbp,%r10
test   %ebx,%ebx
jle    177e <stodola+0x5ae>
lea    0x1(%rbx),%eax
mov    %rax,(%rsp)
mov    0x10(%rsp),%r8
add    $0xfffffffffffffffe,%r8
mov    0x8(%rsp),%rax
mov    %eax,%ebx
and    $0x3,%ebx
mov    %eax,%edi
and    $0xfffffffc,%edi
mov    $0x1,%ebp
mov    0x40(%rsp),%r13
mov    %r8,0x10(%rsp)
mov    %rbx,0x58(%rsp)
mov    %rdi,0x30(%rsp)
jmp    156e <stodola+0x39e>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rbp
cmp    (%rsp),%rbp
je     25a6 <stodola+0x13d6>
mov    $0x1,%eax
cmp    $0x3,%r8
jb     15d1 <stodola+0x401>
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
mov    0x8(%r13,%rax,8),%rcx
movsd  (%rcx,%rbp,8),%xmm0
movsd  %xmm0,0x8(%r14,%rax,8)
mov    0x10(%r13,%rax,8),%rcx
movsd  (%rcx,%rbp,8),%xmm0
movsd  %xmm0,0x10(%r14,%rax,8)
mov    0x18(%r13,%rax,8),%rcx
movsd  (%rcx,%rbp,8),%xmm0
movsd  %xmm0,0x18(%r14,%rax,8)
mov    0x20(%r13,%rax,8),%rcx
movsd  (%rcx,%rbp,8),%xmm0
movsd  %xmm0,0x20(%r14,%rax,8)
add    $0x4,%rax
cmp    %rax,%rdi
jne    1580 <stodola+0x3b0>
add    $0x1,%rax
test   %rbx,%rbx
je     1607 <stodola+0x437>
lea    (%r14,%rax,8),%rcx
lea    0x0(,%rax,8),%rax
add    %r13,%rax
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
mov    (%rax,%rdx,8),%rsi
movsd  (%rsi,%rbp,8),%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%rbx
jne    15f0 <stodola+0x420>
mov    0x48(%rsp),%rdi
mov    0x20(%rsp),%rsi
mov    %r12,%rdx
mov    %r14,%rcx
mov    0x18(%rsp),%rbx
mov    %rbx,%r8
xor    %r9d,%r9d
push   %r10
push   $0x1
call   1060 <ldl_dcmp@plt>
mov    0x348(%rsp),%r10
add    $0x10,%rsp
movl   $0x1,(%r10)
movabs $0x3ff0000000000000,%rax
mov    %rax,0x98(%rsp)
lea    0x98(%rsp),%r13
nopl   0x0(%rax,%rax,1)
sub    $0x8,%rsp
mov    0x50(%rsp),%rdi
mov    0x28(%rsp),%rsi
mov    %r12,%rdx
mov    %r14,%rcx
mov    %rbx,%r8
mov    %r13,%r9
push   %r10
call   1030 <ldl_mprove@plt>
mov    0x348(%rsp),%r10
add    $0x10,%rsp
cmpl   $0x0,(%r10)
jne    1660 <stodola+0x490>
mov    $0x1,%eax
mov    0x10(%rsp),%r8
cmp    $0x3,%r8
mov    0x40(%rsp),%r13
mov    0x50(%rsp),%r9
mov    0x58(%rsp),%rbx
mov    0x30(%rsp),%rdi
jb     170d <stodola+0x53d>
xor    %eax,%eax
mov    0x18(%rsp),%rdx
xchg   %ax,%ax
movsd  0x8(%rdx,%rax,8),%xmm0
mov    0x8(%r9,%rax,8),%rcx
movsd  %xmm0,(%rcx,%rbp,8)
movsd  0x10(%rdx,%rax,8),%xmm0
mov    0x10(%r9,%rax,8),%rcx
movsd  %xmm0,(%rcx,%rbp,8)
movsd  0x18(%rdx,%rax,8),%xmm0
mov    0x18(%r9,%rax,8),%rcx
movsd  %xmm0,(%rcx,%rbp,8)
movsd  0x20(%rdx,%rax,8),%xmm0
mov    0x20(%r9,%rax,8),%rcx
movsd  %xmm0,(%rcx,%rbp,8)
add    $0x4,%rax
cmp    %rax,%rdi
jne    16c0 <stodola+0x4f0>
add    $0x1,%rax
testb  $0x3,0x8(%rsp)
je     1560 <stodola+0x390>
lea    (%r9,%rax,8),%rcx
mov    0x18(%rsp),%rdx
lea    (%rdx,%rax,8),%rax
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movsd  (%rax,%rdx,8),%xmm0
mov    (%rcx,%rdx,8),%rsi
movsd  %xmm0,(%rsi,%rbp,8)
add    $0x1,%rdx
cmp    %rdx,%rbx
jne    1730 <stodola+0x560>
jmp    1560 <stodola+0x390>
mov    %ebx,%esi
mov    %r12,%rdx
mov    %r14,%rcx
mov    %r14,%r8
mov    $0x1,%r9d
mov    0x338(%rsp),%rbp
push   %rbp
push   $0x0
call   1060 <ldl_dcmp@plt>
add    $0x10,%rsp
cmpl   $0x0,0x0(%rbp)
mov    %rbp,%r10
js     258f <stodola+0x13bf>
mov    0x330(%rsp),%rax
movl   $0x0,(%rax)
xorpd  %xmm0,%xmm0
xorpd  %xmm2,%xmm2
mov    0x40(%rsp),%r13
cmpl   $0x0,0x70(%rsp)
jle    24ad <stodola+0x12dd>
lea    0x1(%rbx),%r8d
mov    0x70(%rsp),%rax
add    $0x1,%eax
mov    %rax,0xb8(%rsp)
lea    -0x1(%r8),%rcx
lea    -0x2(%r8),%rax
mov    %rax,0x8(%rsp)
mov    %rcx,%r9
and    $0xfffffffffffffffe,%r9
mov    %ecx,%eax
and    $0x3,%eax
mov    %rax,0x58(%rsp)
mov    %rcx,%rax
mov    %rcx,0x10(%rsp)
and    $0xfffffffffffffffc,%rcx
mov    %rcx,0x80(%rsp)
mov    %r9,%rbp
neg    %rbp
mov    $0x270f,%edi
mov    $0x1,%eax
mov    %rax,(%rsp)
movapd 0x180a(%rip),%xmm4
movsd  %xmm2,0xc0(%rsp)
mov    %r8,0xd8(%rsp)
mov    %r9,0xb0(%rsp)
mov    %rbp,0xd0(%rsp)
test   %ebx,%ebx
jle    18f0 <stodola+0x720>
cmpq   $0x0,0x8(%rsp)
mov    0x50(%rsp),%rsi
mov    $0x1,%eax
movapd %xmm2,%xmm3
jne    1891 <stodola+0x6c1>
testb  $0x1,0x10(%rsp)
je     18f4 <stodola+0x724>
movq   $0x0,(%r12,%rax,8)
mov    (%rsi,%rax,8),%rcx
movsd  (%rcx,%rax,8),%xmm1
ucomisd %xmm1,%xmm0
seta   %cl
ucomisd %xmm3,%xmm1
seta   %dl
test   %dl,%cl
jne    1877 <stodola+0x6a7>
movapd %xmm3,%xmm1
cmovne %eax,%edi
movapd %xmm1,%xmm3
jmp    18f4 <stodola+0x724>
cmovne %ecx,%edi
add    $0x2,%rax
cmp    %r9,%rcx
mov    0x20(%rsp),%rbx
je     1845 <stodola+0x675>
movq   $0x0,(%r12,%rax,8)
mov    (%rsi,%rax,8),%rcx
movsd  (%rcx,%rax,8),%xmm1
ucomisd %xmm1,%xmm0
seta   %cl
ucomisd %xmm3,%xmm1
seta   %dl
test   %dl,%cl
jne    18b8 <stodola+0x6e8>
movapd %xmm3,%xmm1
cmovne %eax,%edi
movq   $0x0,0x8(%r12,%rax,8)
mov    0x8(%rsi,%rax,8),%rcx
movsd  0x8(%rcx,%rax,8),%xmm3
ucomisd %xmm3,%xmm0
seta   %dl
ucomisd %xmm1,%xmm3
seta   %bl
lea    0x1(%rax),%rcx
test   %bl,%dl
jne    1880 <stodola+0x6b0>
movapd %xmm1,%xmm3
jmp    1880 <stodola+0x6b0>
nopl   0x0(%rax,%rax,1)
movapd %xmm2,%xmm3
movsd  %xmm3,0xc8(%rsp)
mov    %edi,0x64(%rsp)
movslq %edi,%rax
movupd %xmm4,(%r12,%rax,8)
mov    %r12,%rdi
mov    %r13,%rsi
mov    %r12,%rdx
mov    %ebx,%ecx
mov    0x18(%rsp),%r8
call   1090 <xtAy@plt>
test   %ebx,%ebx
mov    (%rsp),%rcx
xorpd  %xmm2,%xmm2
jle    1a16 <stodola+0x846>
movapd %xmm0,%xmm3
cmpq   $0x0,0x8(%rsp)
je     19de <stodola+0x80e>
mov    $0x1,%ebx
movsd  %xmm3,0x30(%rsp)
jmp    1974 <stodola+0x7a4>
nopl   0x0(%rax)
movsd  0x8(%r12,%rbx,8),%xmm0
divsd  %xmm4,%xmm0
movsd  %xmm0,0x8(%r12,%rbx,8)
lea    (%rbx,%rbp,1),%rax
add    $0x2,%rax
add    $0x2,%rbx
cmp    $0x1,%rax
je     19e3 <stodola+0x813>
xorps  %xmm4,%xmm4
sqrtsd %xmm3,%xmm4
ucomisd %xmm2,%xmm3
movapd %xmm4,%xmm0
jae    19a8 <stodola+0x7d8>
movapd %xmm3,%xmm0
movsd  %xmm4,0x28(%rsp)
call   10d0 <sqrt@plt>
movsd  0x28(%rsp),%xmm4
movsd  0x30(%rsp),%xmm3
xorpd  %xmm2,%xmm2
mov    (%rsp),%rcx
movsd  (%r12,%rbx,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%r12,%rbx,8)
ucomisd %xmm2,%xmm3
jae    1950 <stodola+0x780>
movapd %xmm3,%xmm0
call   10d0 <sqrt@plt>
movsd  0x30(%rsp),%xmm3
xorpd  %xmm2,%xmm2
mov    (%rsp),%rcx
movapd %xmm0,%xmm4
jmp    1950 <stodola+0x780>
mov    $0x1,%ebx
testb  $0x1,0x10(%rsp)
je     1a16 <stodola+0x846>
ucomisd %xmm2,%xmm3
jb     19f9 <stodola+0x829>
xorps  %xmm0,%xmm0
sqrtsd %xmm3,%xmm0
jmp    1a06 <stodola+0x836>
movapd %xmm3,%xmm0
call   10d0 <sqrt@plt>
mov    (%rsp),%rcx
movsd  (%r12,%rbx,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%r12,%rbx,8)
cmp    $0x2,%rcx
mov    0x20(%rsp),%rbx
jb     1c00 <stodola+0xa30>
mov    %rbx,%r13
mov    $0x1,%ebx
jmp    1a66 <stodola+0x896>
nop
mov    %r14,%rdi
mov    %r12,%rdx
mov    0x20(%rsp),%r13
mov    %r13d,%ecx
mov    0x18(%rsp),%r8
call   1090 <xtAy@plt>
mov    0x88(%rsp),%rsi
movsd  %xmm0,(%rsi,%rbx,8)
add    $0x1,%rbx
mov    (%rsp),%rdi
cmp    %rdi,%rbx
je     1b20 <stodola+0x950>
test   %r13d,%r13d
mov    0x58(%rsp),%r8
mov    0x40(%rsp),%rsi
jle    1a30 <stodola+0x860>
mov    $0x1,%eax
cmpq   $0x3,0x8(%rsp)
jb     1ae1 <stodola+0x911>
xor    %eax,%eax
mov    0x80(%rsp),%rdx
nopl   0x0(%rax)
mov    0x8(%r15,%rax,8),%rcx
movsd  (%rcx,%rbx,8),%xmm0
movsd  %xmm0,0x8(%r14,%rax,8)
mov    0x10(%r15,%rax,8),%rcx
movsd  (%rcx,%rbx,8),%xmm0
movsd  %xmm0,0x10(%r14,%rax,8)
mov    0x18(%r15,%rax,8),%rcx
movsd  (%rcx,%rbx,8),%xmm0
movsd  %xmm0,0x18(%r14,%rax,8)
mov    0x20(%r15,%rax,8),%rcx
movsd  (%rcx,%rbx,8),%xmm0
movsd  %xmm0,0x20(%r14,%rax,8)
add    $0x4,%rax
cmp    %rax,%rdx
jne    1a90 <stodola+0x8c0>
add    $0x1,%rax
test   %r8,%r8
je     1a30 <stodola+0x860>
lea    (%r14,%rax,8),%rcx
lea    (%r15,%rax,8),%rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%rax,%rdx,8),%rdi
movsd  (%rdi,%rbx,8),%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%r8
jne    1b00 <stodola+0x930>
jmp    1a30 <stodola+0x860>
nopl   0x0(%rax)
cmp    $0x2,%rdi
mov    %r13,%rbx
mov    0x40(%rsp),%r13
jb     1c00 <stodola+0xa30>
mov    $0x1,%eax
jmp    1b4d <stodola+0x97d>
nopl   0x0(%rax)
add    $0x1,%rax
cmp    %rdi,%rax
je     1c00 <stodola+0xa30>
test   %ebx,%ebx
jle    1b40 <stodola+0x970>
cmpq   $0x0,0x8(%rsp)
je     1bc0 <stodola+0x9f0>
mov    $0x1,%ecx
xchg   %ax,%ax
movsd  (%rsi,%rax,8),%xmm0
mov    (%r15,%rcx,8),%rdx
mulsd  (%rdx,%rax,8),%xmm0
movsd  (%r12,%rcx,8),%xmm1
subsd  %xmm0,%xmm1
movsd  0x8(%r12,%rcx,8),%xmm0
movsd  %xmm1,(%r12,%rcx,8)
movsd  (%rsi,%rax,8),%xmm1
mov    0x8(%r15,%rcx,8),%rdx
mulsd  (%rdx,%rax,8),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%r12,%rcx,8)
lea    (%rcx,%rbp,1),%rdx
add    $0x2,%rdx
add    $0x2,%rcx
cmp    $0x1,%rdx
jne    1b60 <stodola+0x990>
testb  $0x1,0x10(%rsp)
je     1b40 <stodola+0x970>
jmp    1bd0 <stodola+0xa00>
nopw   0x0(%rax,%rax,1)
mov    $0x1,%ecx
testb  $0x1,0x10(%rsp)
je     1b40 <stodola+0x970>
movsd  (%rsi,%rax,8),%xmm0
mov    (%r15,%rcx,8),%rdx
movsd  (%r12,%rcx,8),%xmm1
mulsd  (%rdx,%rax,8),%xmm0
subsd  %xmm0,%xmm1
movsd  %xmm1,(%r12,%rcx,8)
jmp    1b40 <stodola+0x970>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r12,%rdi
mov    %r13,%rsi
mov    %r12,%rdx
mov    %ebx,%ecx
mov    0x18(%rsp),%r8
call   1090 <xtAy@plt>
test   %ebx,%ebx
jle    1cfe <stodola+0xb2e>
movapd %xmm0,%xmm3
cmpq   $0x0,0x8(%rsp)
je     1cc6 <stodola+0xaf6>
mov    $0x1,%ebx
xorpd  %xmm2,%xmm2
movsd  %xmm3,0x30(%rsp)
jmp    1c64 <stodola+0xa94>
xchg   %ax,%ax
movsd  0x8(%r12,%rbx,8),%xmm0
divsd  %xmm4,%xmm0
movsd  %xmm0,0x8(%r12,%rbx,8)
lea    (%rbx,%rbp,1),%rax
add    $0x2,%rax
add    $0x2,%rbx
cmp    $0x1,%rax
je     1ccb <stodola+0xafb>
xorps  %xmm4,%xmm4
sqrtsd %xmm3,%xmm4
ucomisd %xmm2,%xmm3
movapd %xmm4,%xmm0
jae    1c94 <stodola+0xac4>
movapd %xmm3,%xmm0
movsd  %xmm4,0x28(%rsp)
call   10d0 <sqrt@plt>
movsd  0x28(%rsp),%xmm4
movsd  0x30(%rsp),%xmm3
xorpd  %xmm2,%xmm2
movsd  (%r12,%rbx,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%r12,%rbx,8)
ucomisd %xmm2,%xmm3
jae    1c40 <stodola+0xa70>
movapd %xmm3,%xmm0
call   10d0 <sqrt@plt>
movsd  0x30(%rsp),%xmm3
xorpd  %xmm2,%xmm2
movapd %xmm0,%xmm4
jmp    1c40 <stodola+0xa70>
mov    $0x1,%ebx
xorpd  %xmm0,%xmm0
testb  $0x1,0x10(%rsp)
je     1cfe <stodola+0xb2e>
ucomisd %xmm0,%xmm3
jb     1ce5 <stodola+0xb15>
xorps  %xmm0,%xmm0
sqrtsd %xmm3,%xmm0
jmp    1cee <stodola+0xb1e>
movapd %xmm3,%xmm0
call   10d0 <sqrt@plt>
movsd  (%r12,%rbx,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%r12,%rbx,8)
mov    %r12,%rdi
mov    0x48(%rsp),%rsi
mov    %r12,%rdx
mov    0x20(%rsp),%rbx
mov    %ebx,%ecx
mov    0x18(%rsp),%r8
call   1090 <xtAy@plt>
mov    %rbx,%rcx
mov    0x50(%rsp),%r8
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
test   %ecx,%ecx
movsd  %xmm0,0xe0(%rsp)
jle    1ef0 <stodola+0xd20>
mov    $0x1,%eax
mov    0xd8(%rsp),%rbx
jmp    1d5d <stodola+0xb8d>
add    $0x1,%rax
cmp    %rbx,%rax
je     1e00 <stodola+0xc30>
movq   $0x0,(%r14,%rax,8)
mov    (%r8,%rax,8),%rdi
cmpq   $0x0,0x8(%rsp)
je     1dd0 <stodola+0xc00>
mov    $0x1,%edx
xorpd  %xmm0,%xmm0
nopw   0x0(%rax,%rax,1)
movsd  (%rdi,%rdx,8),%xmm1
mulsd  (%r12,%rdx,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r14,%rax,8)
movsd  0x8(%rdi,%rdx,8),%xmm0
mulsd  0x8(%r12,%rdx,8),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%r14,%rax,8)
lea    (%rdx,%rbp,1),%rsi
add    $0x2,%rsi
add    $0x2,%rdx
cmp    $0x1,%rsi
jne    1d80 <stodola+0xbb0>
testb  $0x1,0x10(%rsp)
je     1d50 <stodola+0xb80>
jmp    1de4 <stodola+0xc14>
nopw   0x0(%rax,%rax,1)
xorpd  %xmm0,%xmm0
mov    $0x1,%edx
testb  $0x1,0x10(%rsp)
je     1d50 <stodola+0xb80>
movsd  (%rdi,%rdx,8),%xmm1
mulsd  (%r12,%rdx,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r14,%rax,8)
jmp    1d50 <stodola+0xb80>
xchg   %ax,%ax
mov    %r14,%rdi
mov    %r13,%rsi
mov    %r14,%rdx
mov    0x18(%rsp),%r8
mov    %rcx,%rbx
call   1090 <xtAy@plt>
test   %ebx,%ebx
mov    (%rsp),%rcx
xorpd  %xmm2,%xmm2
jle    1f50 <stodola+0xd80>
movapd %xmm0,%xmm3
cmpq   $0x0,0x8(%rsp)
je     1f09 <stodola+0xd39>
mov    $0x1,%ebx
movsd  %xmm3,0x30(%rsp)
jmp    1e78 <stodola+0xca8>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  0x8(%r14,%rbx,8),%xmm0
divsd  %xmm4,%xmm0
movsd  %xmm0,0x8(%r14,%rbx,8)
lea    (%rbx,%rbp,1),%rax
add    $0x2,%rax
add    $0x2,%rbx
cmp    $0x1,%rax
je     1f0e <stodola+0xd3e>
xorps  %xmm4,%xmm4
sqrtsd %xmm3,%xmm4
ucomisd %xmm2,%xmm3
movapd %xmm4,%xmm0
jae    1eac <stodola+0xcdc>
movapd %xmm3,%xmm0
movsd  %xmm4,0x28(%rsp)
call   10d0 <sqrt@plt>
movsd  0x28(%rsp),%xmm4
movsd  0x30(%rsp),%xmm3
xorpd  %xmm2,%xmm2
mov    (%rsp),%rcx
movsd  (%r14,%rbx,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%r14,%rbx,8)
ucomisd %xmm2,%xmm3
jae    1e50 <stodola+0xc80>
movapd %xmm3,%xmm0
call   10d0 <sqrt@plt>
movsd  0x30(%rsp),%xmm3
xorpd  %xmm2,%xmm2
mov    (%rsp),%rcx
movapd %xmm0,%xmm4
jmp    1e50 <stodola+0xc80>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r14,%rdi
mov    %r13,%rsi
mov    %r14,%rdx
mov    0x18(%rsp),%r8
call   1090 <xtAy@plt>
mov    (%rsp),%rcx
jmp    1f50 <stodola+0xd80>
mov    $0x1,%ebx
testb  $0x1,0x10(%rsp)
je     1f50 <stodola+0xd80>
ucomisd %xmm2,%xmm3
jb     1f24 <stodola+0xd54>
xorps  %xmm0,%xmm0
sqrtsd %xmm3,%xmm0
jmp    1f31 <stodola+0xd61>
movapd %xmm3,%xmm0
call   10d0 <sqrt@plt>
mov    (%rsp),%rcx
movsd  (%r14,%rbx,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%r14,%rbx,8)
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cmp    $0x2,%rcx
mov    0x20(%rsp),%rbx
jb     2150 <stodola+0xf80>
mov    %rbx,%r13
mov    $0x1,%ebx
jmp    1fa6 <stodola+0xdd6>
nopl   0x0(%rax)
mov    %r12,%rdi
mov    %r14,%rdx
mov    0x20(%rsp),%r13
mov    %r13d,%ecx
mov    0x18(%rsp),%r8
call   1090 <xtAy@plt>
mov    0x88(%rsp),%rsi
movsd  %xmm0,(%rsi,%rbx,8)
add    $0x1,%rbx
mov    (%rsp),%rdi
cmp    %rdi,%rbx
je     2060 <stodola+0xe90>
test   %r13d,%r13d
mov    0x40(%rsp),%rsi
mov    0x58(%rsp),%rbp
jle    1f70 <stodola+0xda0>
mov    $0x1,%eax
cmpq   $0x3,0x8(%rsp)
jb     2021 <stodola+0xe51>
xor    %eax,%eax
mov    0x80(%rsp),%rdx
nopl   0x0(%rax)
mov    0x8(%r15,%rax,8),%rcx
movsd  (%rcx,%rbx,8),%xmm0
movsd  %xmm0,0x8(%r12,%rax,8)
mov    0x10(%r15,%rax,8),%rcx
movsd  (%rcx,%rbx,8),%xmm0
movsd  %xmm0,0x10(%r12,%rax,8)
mov    0x18(%r15,%rax,8),%rcx
movsd  (%rcx,%rbx,8),%xmm0
movsd  %xmm0,0x18(%r12,%rax,8)
mov    0x20(%r15,%rax,8),%rcx
movsd  (%rcx,%rbx,8),%xmm0
movsd  %xmm0,0x20(%r12,%rax,8)
add    $0x4,%rax
cmp    %rax,%rdx
jne    1fd0 <stodola+0xe00>
add    $0x1,%rax
testb  $0x3,0x10(%rsp)
je     1f70 <stodola+0xda0>
lea    (%r12,%rax,8),%rcx
lea    (%r15,%rax,8),%rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
mov    (%rax,%rdx,8),%rdi
movsd  (%rdi,%rbx,8),%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%rbp
jne    2040 <stodola+0xe70>
jmp    1f70 <stodola+0xda0>
nopl   0x0(%rax)
cmp    $0x2,%rdi
mov    %r13,%rbx
mov    0x40(%rsp),%r13
mov    0xd0(%rsp),%rbp
jb     2150 <stodola+0xf80>
mov    $0x1,%eax
jmp    209d <stodola+0xecd>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%rax
cmp    %rdi,%rax
je     2150 <stodola+0xf80>
test   %ebx,%ebx
jle    2090 <stodola+0xec0>
cmpq   $0x0,0x8(%rsp)
je     2110 <stodola+0xf40>
mov    $0x1,%ecx
xchg   %ax,%ax
movsd  (%rsi,%rax,8),%xmm0
mov    (%r15,%rcx,8),%rdx
mulsd  (%rdx,%rax,8),%xmm0
movsd  (%r14,%rcx,8),%xmm1
subsd  %xmm0,%xmm1
movsd  0x8(%r14,%rcx,8),%xmm0
movsd  %xmm1,(%r14,%rcx,8)
movsd  (%rsi,%rax,8),%xmm1
mov    0x8(%r15,%rcx,8),%rdx
mulsd  (%rdx,%rax,8),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%r14,%rcx,8)
lea    (%rcx,%rbp,1),%rdx
add    $0x2,%rdx
add    $0x2,%rcx
cmp    $0x1,%rdx
jne    20b0 <stodola+0xee0>
testb  $0x1,0x10(%rsp)
je     2090 <stodola+0xec0>
jmp    2120 <stodola+0xf50>
nopw   0x0(%rax,%rax,1)
mov    $0x1,%ecx
testb  $0x1,0x10(%rsp)
je     2090 <stodola+0xec0>
movsd  (%rsi,%rax,8),%xmm0
mov    (%r15,%rcx,8),%rdx
movsd  (%r14,%rcx,8),%xmm1
mulsd  (%rdx,%rax,8),%xmm0
subsd  %xmm0,%xmm1
movsd  %xmm1,(%r14,%rcx,8)
jmp    2090 <stodola+0xec0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r14,%rdi
mov    %r13,%rsi
mov    %r14,%rdx
mov    %ebx,%ecx
mov    0x18(%rsp),%r8
call   1090 <xtAy@plt>
test   %ebx,%ebx
jle    2284 <stodola+0x10b4>
movapd %xmm0,%xmm2
cmpq   $0x0,0x8(%rsp)
je     2240 <stodola+0x1070>
mov    $0x1,%ebx
xorpd  %xmm1,%xmm1
movsd  %xmm2,0x30(%rsp)
jmp    21b1 <stodola+0xfe1>
xchg   %ax,%ax
divsd  %xmm3,%xmm0
movsd  %xmm0,0x8(%r12,%rbx,8)
lea    (%rbx,%rbp,1),%rax
add    $0x2,%rax
add    $0x2,%rbx
cmp    $0x1,%rax
je     2245 <stodola+0x1075>
movsd  (%r14,%rbx,8),%xmm4
xorps  %xmm3,%xmm3
sqrtsd %xmm2,%xmm3
ucomisd %xmm1,%xmm2
movapd %xmm3,%xmm0
jae    21f9 <stodola+0x1029>
movapd %xmm2,%xmm0
movsd  %xmm3,0x28(%rsp)
movsd  %xmm4,0xe8(%rsp)
call   10d0 <sqrt@plt>
movsd  0xe8(%rsp),%xmm4
movsd  0x28(%rsp),%xmm3
movsd  0x30(%rsp),%xmm2
xorpd  %xmm1,%xmm1
divsd  %xmm0,%xmm4
movsd  %xmm4,(%r12,%rbx,8)
movsd  0x8(%r14,%rbx,8),%xmm0
ucomisd %xmm1,%xmm2
jae    2190 <stodola+0xfc0>
movsd  %xmm0,0x28(%rsp)
movapd %xmm2,%xmm0
call   10d0 <sqrt@plt>
movsd  0x30(%rsp),%xmm2
xorpd  %xmm1,%xmm1
movapd %xmm0,%xmm3
movsd  0x28(%rsp),%xmm0
jmp    2190 <stodola+0xfc0>
nopl   0x0(%rax,%rax,1)
mov    $0x1,%ebx
xorpd  %xmm0,%xmm0
testb  $0x1,0x10(%rsp)
je     2284 <stodola+0x10b4>
movsd  (%r14,%rbx,8),%xmm1
ucomisd %xmm0,%xmm2
jb     2265 <stodola+0x1095>
xorps  %xmm0,%xmm0
sqrtsd %xmm2,%xmm0
jmp    227a <stodola+0x10aa>
movapd %xmm2,%xmm0
movsd  %xmm1,0x30(%rsp)
call   10d0 <sqrt@plt>
movsd  0x30(%rsp),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%r12,%rbx,8)
mov    %r12,%rdi
mov    0x48(%rsp),%rsi
mov    %r12,%rdx
mov    0x20(%rsp),%rcx
mov    0x18(%rsp),%r8
call   1090 <xtAy@plt>
mov    0x330(%rsp),%rdx
mov    (%rdx),%eax
lea    0x1(%rax),%ecx
mov    %ecx,(%rdx)
movapd %xmm0,%xmm1
subsd  0xe0(%rsp),%xmm1
andpd  0xd5e(%rip),%xmm1
divsd  %xmm0,%xmm1
cmp    $0x7d0,%eax
jge    2566 <stodola+0x1396>
ucomisd 0x78(%rsp),%xmm1
mov    0x50(%rsp),%r8
mov    0x58(%rsp),%rbx
mov    0x20(%rsp),%rcx
ja     1d30 <stodola+0xb60>
test   %ecx,%ecx
mov    (%rsp),%rdi
jle    2397 <stodola+0x11c7>
mov    $0x1,%eax
cmpq   $0x3,0x8(%rsp)
jb     2361 <stodola+0x1191>
xor    %eax,%eax
mov    0x80(%rsp),%rdx
nop
movsd  0x8(%r14,%rax,8),%xmm0
mov    0x8(%r15,%rax,8),%rsi
movsd  %xmm0,(%rsi,%rdi,8)
movsd  0x10(%r14,%rax,8),%xmm0
mov    0x10(%r15,%rax,8),%rsi
movsd  %xmm0,(%rsi,%rdi,8)
movsd  0x18(%r14,%rax,8),%xmm0
mov    0x18(%r15,%rax,8),%rsi
movsd  %xmm0,(%rsi,%rdi,8)
movsd  0x20(%r14,%rax,8),%xmm0
mov    0x20(%r15,%rax,8),%rsi
movsd  %xmm0,(%rsi,%rdi,8)
add    $0x4,%rax
cmp    %rax,%rdx
jne    2310 <stodola+0x1140>
add    $0x1,%rax
testb  $0x3,0x10(%rsp)
je     2397 <stodola+0x11c7>
lea    (%r15,%rax,8),%r8
lea    (%r14,%rax,8),%rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rax,%rdx,8),%xmm0
mov    (%r8,%rdx,8),%rsi
movsd  %xmm0,(%rsi,%rdi,8)
add    $0x1,%rdx
cmp    %rdx,%rbx
jne    2380 <stodola+0x11b0>
movapd %xmm1,0x30(%rsp)
mov    %r12,%rdi
mov    0x48(%rsp),%rsi
mov    %r12,%rdx
mov    0x18(%rsp),%r8
call   1090 <xtAy@plt>
mov    (%rsp),%rcx
movapd 0xa0(%rsp),%xmm3
movapd %xmm3,%xmm1
subsd  %xmm0,%xmm1
movapd %xmm3,%xmm2
cmpltsd %xmm0,%xmm2
subsd  %xmm3,%xmm0
andpd  %xmm2,%xmm0
andnpd %xmm1,%xmm2
orpd   %xmm0,%xmm2
mov    0x68(%rsp),%rax
movlpd %xmm2,(%rax,%rcx,8)
cmpl   $0x0,0x340(%rsp)
je     2464 <stodola+0x1294>
mov    0x2be5(%rip),%rbx
mov    (%rbx),%edi
lea    0xc68(%rip),%rsi
mov    (%rsp),%rdx
mov    0x64(%rsp),%ecx
xor    %eax,%eax
call   1050 <fprintf@plt>
mov    (%rbx),%ebx
mov    0x68(%rsp),%rax
mov    (%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     2433 <stodola+0x1263>
sqrtsd %xmm0,%xmm0
jmp    2438 <stodola+0x1268>
call   10d0 <sqrt@plt>
movapd 0x30(%rsp),%xmm1
divsd  0xbc2(%rip),%xmm0
mov    0x330(%rsp),%rax
mov    (%rax),%edx
mov    %ebx,%edi
lea    0xc29(%rip),%rsi
mov    $0x2,%al
call   1050 <fprintf@plt>
mov    (%rsp),%rcx
add    $0x1,%rcx
movsd  0xc8(%rsp),%xmm0
mov    %rcx,(%rsp)
cmp    0xb8(%rsp),%rcx
mov    0x338(%rsp),%r10
movsd  0xc0(%rsp),%xmm2
mov    0xb0(%rsp),%r9
mov    0x64(%rsp),%edi
movapd 0xb6e(%rip),%xmm4
mov    0x20(%rsp),%rbx
jne    1827 <stodola+0x657>
mov    0x68(%rsp),%rdi
mov    %r15,%rsi
mov    %ebx,%edx
mov    %rbx,%rbp
mov    0x70(%rsp),%rbx
mov    %ebx,%ecx
mov    %r10,%r15
call   10f0 <eigsort@plt>
movslq 0x94(%rsp),%rax
movsd  0x78(%rsp),%xmm1
mov    0x68(%rsp),%rcx
addsd  (%rcx,%rax,8),%xmm1
mov    0x48(%rsp),%rdi
mov    %r13,%rsi
mov    %ebp,%edx
mov    %ebx,%ecx
movapd 0xa0(%rsp),%xmm0
mov    0x340(%rsp),%r8d
call   10a0 <sturm@plt>
mov    %eax,(%r15)
mov    0x50(%rsp),%rdi
mov    $0x1,%esi
mov    %ebp,%edx
mov    $0x1,%ecx
mov    %ebp,%r8d
call   10c0 <free_dmatrix@plt>
mov    0x18(%rsp),%rdi
mov    $0x1,%esi
mov    %ebp,%edx
call   10b0 <free_dvector@plt>
mov    %r12,%rdi
mov    $0x1,%esi
mov    %ebp,%edx
call   10b0 <free_dvector@plt>
mov    %r14,%rdi
mov    $0x1,%esi
mov    %ebp,%edx
call   10b0 <free_dvector@plt>
mov    0x88(%rsp),%rdi
mov    $0x1,%esi
mov    %ebx,%edx
call   10b0 <free_dvector@plt>
xor    %eax,%eax
jmp    2594 <stodola+0x13c4>
lea    0xac3(%rip),%rsi
lea    0xf0(%rsp),%rbx
mov    %rbx,%rdi
movapd %xmm1,%xmm0
movsd  0x78(%rsp),%xmm1
call   10e0 <sprintf@plt>
mov    %rbx,%rdi
call   1070 <errorMsg@plt>
mov    $0x20,%eax
add    $0x2f8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x330(%rsp),%rax
movl   $0x0,(%rax)
mov    0x20(%rsp),%rbx
test   %ebx,%ebx
jle    25d8 <stodola+0x1408>
mov    0x8(%rsp),%rbp
mov    %ebp,%eax
and    $0x3,%eax
cmp    $0x3,%r8
jae    25e5 <stodola+0x1415>
xorpd  %xmm1,%xmm1
mov    $0x1,%ecx
jmp    263e <stodola+0x146e>
xorpd  %xmm0,%xmm0
xorpd  %xmm2,%xmm2
jmp    1799 <stodola+0x5c9>
mov    %ebp,%edx
and    $0xfffffffc,%edx
xorpd  %xmm1,%xmm1
xor    %ecx,%ecx
mov    0x8(%r9,%rcx,8),%rsi
mov    0x10(%r9,%rcx,8),%rbp
movsd  0x8(%rsi,%rcx,8),%xmm0
maxsd  %xmm1,%xmm0
movsd  0x10(%rbp,%rcx,8),%xmm1
maxsd  %xmm0,%xmm1
mov    0x18(%r9,%rcx,8),%rsi
movsd  0x18(%rsi,%rcx,8),%xmm0
maxsd  %xmm1,%xmm0
mov    0x20(%r9,%rcx,8),%rsi
movsd  0x20(%rsi,%rcx,8),%xmm1
maxsd  %xmm0,%xmm1
add    $0x4,%rcx
cmp    %rcx,%rdx
jne    25f0 <stodola+0x1420>
add    $0x1,%rcx
mov    0x8(%rsp),%rbp
movapd %xmm1,%xmm0
test   %rax,%rax
je     266b <stodola+0x149b>
nopw   0x0(%rax,%rax,1)
mov    (%r9,%rcx,8),%rdx
movsd  (%rdx,%rcx,8),%xmm0
maxsd  %xmm1,%xmm0
add    $0x1,%rcx
movapd %xmm0,%xmm1
add    $0xffffffffffffffff,%rax
jne    2650 <stodola+0x1480>
test   %ebx,%ebx
jle    2685 <stodola+0x14b5>
mov    %ebp,%eax
and    $0x3,%eax
cmp    $0x3,%r8
jae    268e <stodola+0x14be>
mov    $0x1,%ecx
movapd %xmm0,%xmm2
jmp    26e9 <stodola+0x1519>
movapd %xmm0,%xmm2
jmp    1799 <stodola+0x5c9>
and    $0xfffffffc,%ebp
xor    %ecx,%ecx
movapd %xmm0,%xmm2
nopw   0x0(%rax,%rax,1)
mov    0x8(%r9,%rcx,8),%rdx
mov    0x10(%r9,%rcx,8),%rsi
movsd  0x8(%rdx,%rcx,8),%xmm1
minsd  %xmm2,%xmm1
movsd  0x10(%rsi,%rcx,8),%xmm2
minsd  %xmm1,%xmm2
mov    0x18(%r9,%rcx,8),%rdx
movsd  0x18(%rdx,%rcx,8),%xmm1
minsd  %xmm2,%xmm1
mov    0x20(%r9,%rcx,8),%rdx
movsd  0x20(%rdx,%rcx,8),%xmm2
minsd  %xmm1,%xmm2
add    $0x4,%rcx
cmp    %rcx,%rbp
jne    26a0 <stodola+0x14d0>
add    $0x1,%rcx
test   %rax,%rax
je     1799 <stodola+0x5c9>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movapd %xmm2,%xmm1
mov    (%r9,%rcx,8),%rdx
movsd  (%rdx,%rcx,8),%xmm2
minsd  %xmm1,%xmm2
add    $0x1,%rcx
add    $0xffffffffffffffff,%rax
jne    2700 <stodola+0x1530>
jmp    1799 <stodola+0x5c9>

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

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