#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 cholmod(double *, int, double *, double, double);
int /*<<< orphan*/ free(double *);
double l2norm(double *, int);
int /*<<< orphan*/ linsolve_lower(double *, int, double *, double *);
scalar_t__ malloc(int);
int /*<<< orphan*/ scale(double *, int, int, double);
double sqrt(double);
void trstep(double *jac, double *sN, int N, double *dx, double *L, double *hess,
            double nlen, double *ioval, double eps, double *step) {
  int i, c1, iter, j;
  double sum, tvec, l1, l2, maxadd, steplen;
  double hi, lo, lambdalo, lambdahi;
  double delta, lambda, deltaprev, phi, phid, phidinit;
  double *temp1, *temp2;
  hi = 1.5;
  lo = 0.75;
  delta = ioval[0];
  lambda = ioval[1];
  deltaprev = ioval[2];
  phi = ioval[3];
  phid = ioval[4];
  phidinit = ioval[5];
  temp1 = (double *)malloc(sizeof(double) * N);
  temp2 = (double *)malloc(sizeof(double) * N);
  if (nlen <= hi * delta) {
    ioval[6] = 1.0;
    for (i = 0; i < N; ++i) {
      step[i] = sN[i];
    }
    lambda = 0.;
    if (delta > nlen) {
      delta = nlen;
    }
  } else {
    ioval[6] = 0.0;
    if (lambda > 0.) {
      lambda -=
          (phi + deltaprev) * ((deltaprev - delta) + phi) / (delta * phid);
    }
    phi = nlen - delta;
    if (ioval[7] == 1.0) {
      ioval[7] = 0.0;
      for (i = 0; i < N; ++i) {
        temp1[i] = dx[i] * dx[i] * sN[i];
      }
      temp2[0] = temp1[0] / L[0];
      for (i = 1; i < N; ++i) {
        sum = 0.;
        c1 = i * N;
        for (j = 0; j < i; ++j) {
          sum += temp2[j] * L[c1 + j];
        }
        temp2[i] = (temp1[i] - sum) / L[c1 + i];
      }
      tvec = l2norm(temp2, N);
      phidinit = -tvec * tvec / nlen;
    }
    lambdalo = -phi / phidinit;
    for (i = 0; i < N; ++i) {
      temp1[i] = jac[i] / dx[i];
    }
    tvec = l2norm(temp1, N);
    lambdahi = tvec / delta;
    iter = 0;
    while (iter == 0) {
      if (lambda < lambdalo || lambda > lambdahi) {
        l1 = sqrt(lambdalo * lambdahi);
        l2 = 0.001 * lambdahi;
        if (l1 > l2) {
          lambda = l1;
        } else {
          lambda = l2;
        }
      }
      for (i = 0; i < N; ++i) {
        c1 = i * N;
        hess[c1 + i] += lambda * dx[i] * dx[i];
      }
      maxadd = cholmod(hess, N, L, eps, 0.0);
      scale(jac, 1, N, -1.0);
      linsolve_lower(L, N, jac, step);
      scale(jac, 1, N, -1.0);
      for (i = 0; i < N; ++i) {
        c1 = i * N;
        hess[c1 + i] -= lambda * dx[i] * dx[i];
      }
      for (i = 0; i < N; ++i) {
        temp1[i] = step[i] * dx[i];
      }
      steplen = l2norm(temp1, N);
      phi = steplen - delta;
      for (i = 0; i < N; ++i) {
        temp1[i] *= dx[i];
      }
      temp2[0] = temp1[0] / L[0];
      for (i = 1; i < N; ++i) {
        sum = 0.;
        c1 = i * N;
        for (j = 0; j < i; ++j) {
          sum += temp2[j] * L[c1 + j];
        }
        temp2[i] = (temp1[i] - sum) / L[c1 + i];
      }
      tvec = l2norm(temp2, N);
      phid = -tvec * tvec / steplen;
      if ((steplen >= lo * delta && steplen <= hi * delta) ||
          (lambdahi - lambdalo >= 0)) {
        iter = 1;
      } else {
        if (lambdalo <= lambda - (phi / phid)) {
          lambdalo = lambda - (phi / phid);
        }
        if (phi < 0) {
          lambdalo = lambda;
        }
        lambda -= (steplen * phi) / (delta * phid);
      }
    }
  }
  ioval[0] = delta;
  ioval[1] = lambda;
  ioval[2] = deltaprev;
  ioval[3] = phi;
  ioval[4] = phid;
  ioval[5] = phidinit;
  free(temp1);
  free(temp2);
}


x86 assembly (clang, -O0):
<trstep>:
push   %rbp
mov    %rsp,%rbp
sub    $0xe0,%rsp
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movsd  %xmm0,-0x38(%rbp)
movsd  %xmm1,-0x40(%rbp)
movsd  0xe5c(%rip),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  0xe44(%rip),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    0x10(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    0x10(%rbp),%rax
movsd  0x20(%rax),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    0x10(%rbp),%rax
movsd  0x28(%rax),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movslq -0x14(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0xd8(%rbp)
movslq -0x14(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0xe0(%rbp)
movsd  -0x38(%rbp),%xmm1
movsd  -0x88(%rbp),%xmm0
ff
mulsd  -0xa8(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jb     12f0 <trstep+0x180>
mov    0x10(%rbp),%rax
movsd  0xd90(%rip),%xmm0
movsd  %xmm0,0x30(%rax)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12c0 <trstep+0x150>
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    128c <trstep+0x11c>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
ucomisd -0x38(%rbp),%xmm0
jbe    12eb <trstep+0x17b>
movsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
jmp    1aa6 <trstep+0x936>
mov    0x10(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x30(%rax)
movsd  -0xb0(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1365 <trstep+0x1f5>
movsd  -0xc0(%rbp),%xmm1
ff
addsd  -0xb8(%rbp),%xmm1
ff
movsd  -0xb8(%rbp),%xmm0
ff
subsd  -0xa8(%rbp),%xmm0
ff
addsd  -0xc0(%rbp),%xmm0
ff
mulsd  %xmm0,%xmm1
movsd  -0xa8(%rbp),%xmm0
ff
mulsd  -0xc8(%rbp),%xmm0
ff
divsd  %xmm0,%xmm1
movsd  -0xb0(%rbp),%xmm0
ff
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x38(%rbp),%xmm0
subsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xc0(%rbp)
ff
mov    0x10(%rbp),%rax
movsd  0x38(%rax),%xmm0
movsd  0xc85(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    151e <trstep+0x3ae>
jp     151e <trstep+0x3ae>
mov    0x10(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x38(%rax)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    13ff <trstep+0x28f>
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0xd8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    13ae <trstep+0x23e>
mov    -0xd8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x28(%rbp),%rax
divsd  (%rax),%xmm0
mov    -0xe0(%rbp),%rax
movsd  %xmm0,(%rax)
movl   $0x1,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    14dc <trstep+0x36c>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x44(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    %eax,-0x48(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    1497 <trstep+0x327>
mov    -0xe0(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1449 <trstep+0x2d9>
mov    -0xd8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x58(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    -0xe0(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1424 <trstep+0x2b4>
mov    -0xe0(%rbp),%rdi
mov    -0x14(%rbp),%esi
call   1040 <l2norm@plt>
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x60(%rbp),%xmm0
divsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
divsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1598 <trstep+0x428>
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    -0xd8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1554 <trstep+0x3e4>
mov    -0xd8(%rbp),%rdi
mov    -0x14(%rbp),%esi
call   1040 <l2norm@plt>
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
divsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movl   $0x0,-0x4c(%rbp)
cmpl   $0x0,-0x4c(%rbp)
jne    1aa1 <trstep+0x931>
movsd  -0xb0(%rbp),%xmm1
ff
movsd  -0x98(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
ja     1602 <trstep+0x492>
movsd  -0xb0(%rbp),%xmm0
ff
ucomisd -0xa0(%rbp),%xmm0
ff
jbe    1665 <trstep+0x4f5>
movsd  -0x98(%rbp),%xmm0
ff
mulsd  -0xa0(%rbp),%xmm0
ff
call   1090 <sqrt@plt>
movsd  %xmm0,-0x68(%rbp)
movsd  0x9f4(%rip),%xmm0
mulsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x70(%rbp)
movsd  -0x68(%rbp),%xmm0
ucomisd -0x70(%rbp),%xmm0
jbe    1653 <trstep+0x4e3>
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
jmp    1660 <trstep+0x4f0>
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
jmp    1665 <trstep+0x4f5>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    16d1 <trstep+0x561>
mov    -0x44(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    %eax,-0x48(%rbp)
movsd  -0xb0(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x30(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    166c <trstep+0x4fc>
mov    -0x30(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x28(%rbp),%rdx
movsd  -0x40(%rbp),%xmm0
xorps  %xmm1,%xmm1
call   1060 <cholmod@plt>
movsd  %xmm0,-0x78(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%edx
mov    $0x1,%esi
movsd  0x91e(%rip),%xmm0
call   1080 <scale@plt>
mov    -0x28(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x8(%rbp),%rdx
mov    0x18(%rbp),%rcx
call   1050 <linsolve_lower@plt>
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%edx
mov    $0x1,%esi
movsd  0x8f1(%rip),%xmm0
call   1080 <scale@plt>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    17b7 <trstep+0x647>
mov    -0x44(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    %eax,-0x48(%rbp)
movsd  -0xb0(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x30(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%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    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    173b <trstep+0x5cb>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1802 <trstep+0x692>
mov    0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0xd8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    17be <trstep+0x64e>
mov    -0xd8(%rbp),%rdi
mov    -0x14(%rbp),%esi
call   1040 <l2norm@plt>
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm0
subsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xc0(%rbp)
ff
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    186e <trstep+0x6fe>
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xd8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1832 <trstep+0x6c2>
mov    -0xd8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x28(%rbp),%rax
divsd  (%rax),%xmm0
mov    -0xe0(%rbp),%rax
movsd  %xmm0,(%rax)
movl   $0x1,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    194b <trstep+0x7db>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x44(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    %eax,-0x48(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    1906 <trstep+0x796>
mov    -0xe0(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    18b8 <trstep+0x748>
mov    -0xd8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x58(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    -0xe0(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1893 <trstep+0x723>
mov    -0xe0(%rbp),%rdi
mov    -0x14(%rbp),%esi
call   1040 <l2norm@plt>
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x60(%rbp),%xmm0
divsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
movsd  -0x90(%rbp),%xmm1
ff
mulsd  -0xa8(%rbp),%xmm1
ff
ucomisd %xmm1,%xmm0
jb     19cb <trstep+0x85b>
movsd  -0x80(%rbp),%xmm1
movsd  -0x88(%rbp),%xmm0
ff
mulsd  -0xa8(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jae    19e8 <trstep+0x878>
movsd  -0xa0(%rbp),%xmm0
ff
subsd  -0x98(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     19f4 <trstep+0x884>
movl   $0x1,-0x4c(%rbp)
jmp    1a9c <trstep+0x92c>
movsd  -0x98(%rbp),%xmm1
ff
movsd  -0xb0(%rbp),%xmm0
ff
movsd  -0xc0(%rbp),%xmm2
ff
divsd  -0xc8(%rbp),%xmm2
ff
subsd  %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jb     1a46 <trstep+0x8d6>
movsd  -0xb0(%rbp),%xmm0
ff
movsd  -0xc0(%rbp),%xmm1
ff
divsd  -0xc8(%rbp),%xmm1
ff
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
xorps  %xmm0,%xmm0
ucomisd -0xc0(%rbp),%xmm0
ff
jbe    1a67 <trstep+0x8f7>
movsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x80(%rbp),%xmm1
mulsd  -0xc0(%rbp),%xmm1
ff
movsd  -0xa8(%rbp),%xmm0
ff
mulsd  -0xc8(%rbp),%xmm0
ff
divsd  %xmm0,%xmm1
movsd  -0xb0(%rbp),%xmm0
ff
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
jmp    15c8 <trstep+0x458>
jmp    1aa6 <trstep+0x936>
movsd  -0xa8(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0xb0(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0xb8(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movsd  -0xc0(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movsd  %xmm0,0x18(%rax)
movsd  -0xc8(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movsd  %xmm0,0x20(%rax)
movsd  -0xd0(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movsd  %xmm0,0x28(%rax)
mov    -0xd8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xe0(%rbp),%rdi
call   1030 <free@plt>
add    $0xe0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<trstep>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x138,%rsp
movsd  %xmm1,0xd8(%rsp)
movsd  %xmm0,0x40(%rsp)
mov    %r9,%r13
mov    %r8,0x10(%rsp)
mov    %rcx,0x28(%rsp)
mov    %edx,%r12d
mov    %rsi,0x20(%rsp)
mov    %rdi,0x48(%rsp)
mov    0x178(%rsp),%rax
mov    %rax,0x30(%rsp)
mov    0x170(%rsp),%rbp
movsd  0x0(%rbp),%xmm0
movsd  %xmm0,0x38(%rsp)
movsd  0x8(%rbp),%xmm0
movaps %xmm0,0x50(%rsp)
movsd  0x10(%rbp),%xmm0
movsd  %xmm0,0xa0(%rsp)
movsd  0x18(%rbp),%xmm0
movaps %xmm0,0xe0(%rsp)
movsd  0x20(%rbp),%xmm0
movaps %xmm0,0xf0(%rsp)
movsd  0x28(%rbp),%xmm0
movaps %xmm0,0x100(%rsp)
lea    0x0(,%r12,8),%ebx
mov    %ebx,%edi
call   1070 <malloc@plt>
mov    %rax,%r14
mov    %ebx,%edi
call   1070 <malloc@plt>
movsd  0x40(%rsp),%xmm5
movsd  0x38(%rsp),%xmm2
mov    %rax,%r15
movsd  0x1dc7(%rip),%xmm0
mulsd  %xmm2,%xmm0
movsd  %xmm0,0x128(%rsp)
ucomisd %xmm5,%xmm0
jae    139d <trstep+0x22d>
mov    %r12,0x8(%rsp)
movq   $0x0,0x30(%rbp)
xorpd  %xmm0,%xmm0
movapd 0x50(%rsp),%xmm3
ucomisd %xmm0,%xmm3
mov    %rbp,%r10
jbe    12ab <trstep+0x13b>
movsd  0xa0(%rsp),%xmm1
movapd %xmm1,%xmm0
movapd 0xe0(%rsp),%xmm4
addsd  %xmm4,%xmm0
subsd  %xmm2,%xmm1
addsd  %xmm4,%xmm1
mulsd  %xmm0,%xmm1
movapd 0xf0(%rsp),%xmm0
mulsd  %xmm2,%xmm0
divsd  %xmm0,%xmm1
subsd  %xmm1,%xmm3
mov    0x30(%rsp),%rbx
mov    0x8(%rsp),%rsi
mov    0x10(%rsp),%rbp
mov    0x28(%rsp),%r8
mov    0x48(%rsp),%rax
mov    0x20(%rsp),%r12
movabs $0x7ffffffffffffffe,%rcx
ff ff 7f
mov    %rcx,0x68(%rsp)
movapd %xmm5,%xmm4
subsd  %xmm2,%xmm4
movsd  0x38(%r10),%xmm0
ucomisd 0x1d1a(%rip),%xmm0
movapd %xmm3,0x50(%rsp)
jne    1743 <trstep+0x5d3>
jp     1743 <trstep+0x5d3>
movq   $0x0,0x38(%r10)
test   %esi,%esi
movapd %xmm4,0x80(%rsp)
jle    1470 <trstep+0x300>
mov    %esi,%r9d
cmp    $0x4,%esi
jae    1487 <trstep+0x317>
xor    %ecx,%ecx
mov    %rcx,%rax
not    %rax
test   $0x1,%r9b
je     134d <trstep+0x1dd>
movsd  (%r8,%rcx,8),%xmm0
mulsd  %xmm0,%xmm0
mulsd  (%r12,%rcx,8),%xmm0
movsd  %xmm0,(%r14,%rcx,8)
or     $0x1,%rcx
add    %r9,%rax
je     15c0 <trstep+0x450>
cs nopw 0x0(%rax,%rax,1)
movsd  (%r8,%rcx,8),%xmm0
mulsd  %xmm0,%xmm0
mulsd  (%r12,%rcx,8),%xmm0
movsd  %xmm0,(%r14,%rcx,8)
movsd  0x8(%r8,%rcx,8),%xmm0
mulsd  %xmm0,%xmm0
mulsd  0x8(%r12,%rcx,8),%xmm0
movsd  %xmm0,0x8(%r14,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%r9
jne    1360 <trstep+0x1f0>
jmp    15c0 <trstep+0x450>
movabs $0x3ff0000000000000,%rax
mov    %rax,0x30(%rbp)
test   %r12d,%r12d
mov    0x30(%rsp),%rbx
mov    %r12,%rcx
mov    0x20(%rsp),%r12
mov    %rbp,%rax
movapd 0xf0(%rsp),%xmm7
jle    2408 <trstep+0x1298>
mov    %ecx,%r8d
cmp    $0x4,%ecx
jb     13ef <trstep+0x27f>
lea    (%r12,%r8,8),%rcx
cmp    %rbx,%rcx
jbe    182b <trstep+0x6bb>
lea    (%rbx,%r8,8),%rcx
cmp    %r12,%rcx
jbe    182b <trstep+0x6bb>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %r8,%rdx
mov    %r8,%rsi
and    $0x3,%rsi
je     1425 <trstep+0x2b5>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%r12,%rcx,8),%xmm0
movsd  %xmm0,(%rbx,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    1410 <trstep+0x2a0>
cmp    $0x3,%rdx
jb     2408 <trstep+0x1298>
nop
movsd  (%r12,%rcx,8),%xmm0
movsd  %xmm0,(%rbx,%rcx,8)
movsd  0x8(%r12,%rcx,8),%xmm0
movsd  %xmm0,0x8(%rbx,%rcx,8)
movsd  0x10(%r12,%rcx,8),%xmm0
movsd  %xmm0,0x10(%rbx,%rcx,8)
movsd  0x18(%r12,%rcx,8),%xmm0
movsd  %xmm0,0x18(%rbx,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%r8
jne    1430 <trstep+0x2c0>
jmp    2408 <trstep+0x1298>
mov    %r10,%r12
movsd  (%r14),%xmm0
divsd  0x0(%rbp),%xmm0
movsd  %xmm0,(%r15)
jmp    16fc <trstep+0x58c>
lea    (%r14,%r9,8),%rcx
lea    (%r8,%r9,8),%rax
cmp    %rax,%r14
setb   %bl
cmp    %r8,%rcx
seta   %dl
lea    (%r12,%r9,8),%rax
cmp    %rax,%r14
setb   %al
cmp    %r12,%rcx
seta   %dil
xor    %ecx,%ecx
test   %dl,%bl
jne    247d <trstep+0x130d>
and    %dil,%al
mov    0x30(%rsp),%rbx
jne    1327 <trstep+0x1b7>
mov    %r9d,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rax
mov    %rax,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rax,%rax
je     2487 <trstep+0x1317>
mov    %rdx,%rdi
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
and    %rax,%rdi
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd (%r8,%rax,8),%xmm0
movupd 0x10(%r8,%rax,8),%xmm1
mulpd  %xmm0,%xmm0
mulpd  %xmm1,%xmm1
movupd (%r12,%rax,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%r12,%rax,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,(%r14,%rax,8)
movupd %xmm0,0x10(%r14,%rax,8)
movupd 0x20(%r8,%rax,8),%xmm0
movupd 0x30(%r8,%rax,8),%xmm1
mulpd  %xmm0,%xmm0
mulpd  %xmm1,%xmm1
movupd 0x20(%r12,%rax,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x30(%r12,%rax,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,0x20(%r14,%rax,8)
movupd %xmm0,0x30(%r14,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rdi
jne    1500 <trstep+0x390>
test   $0x1,%dl
je     15b7 <trstep+0x447>
movupd (%r8,%rax,8),%xmm0
movupd 0x10(%r8,%rax,8),%xmm1
mulpd  %xmm0,%xmm0
mulpd  %xmm1,%xmm1
movupd (%r12,%rax,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%r12,%rax,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,(%r14,%rax,8)
movupd %xmm0,0x10(%r14,%rax,8)
cmp    %r9,%rcx
jne    1327 <trstep+0x1b7>
mov    %r10,%r12
movsd  (%r14),%xmm0
divsd  0x0(%rbp),%xmm0
movsd  %xmm0,(%r15)
cmp    $0x2,%esi
jl     16fc <trstep+0x58c>
mov    0x10(%rsp),%rax
lea    (%rax,%r9,8),%rcx
add    $0x18,%rcx
lea    0x0(,%r9,8),%r8
mov    $0x1,%eax
xor    %r11d,%r11d
mov    %r9,%r10
jmp    1639 <trstep+0x4c9>
nopl   (%rax)
movsd  (%r14,%rax,8),%xmm1
subsd  %xmm0,%xmm1
add    %rax,%rsi
mov    0x10(%rsp),%rdx
divsd  (%rdx,%rsi,8),%xmm1
movsd  %xmm1,(%r15,%rax,8)
add    $0x1,%rax
add    $0x1,%r11
add    %r8,%rcx
add    %r9,%r10
cmp    %r9,%rax
mov    0x30(%rsp),%rbx
je     16fc <trstep+0x58c>
cmp    $0x3,%r11
jae    1650 <trstep+0x4e0>
xorpd  %xmm0,%xmm0
xor    %edx,%edx
jmp    16ab <trstep+0x53b>
nopw   0x0(%rax,%rax,1)
mov    %rax,%rsi
and    $0xfffffffffffffffc,%rsi
xorpd  %xmm0,%xmm0
xor    %edx,%edx
nopl   (%rax)
movsd  (%r15,%rdx,8),%xmm1
movsd  0x8(%r15,%rdx,8),%xmm2
mulsd  -0x18(%rcx,%rdx,8),%xmm1
mulsd  -0x10(%rcx,%rdx,8),%xmm2
addsd  %xmm0,%xmm1
movsd  0x10(%r15,%rdx,8),%xmm3
mulsd  -0x8(%rcx,%rdx,8),%xmm3
addsd  %xmm1,%xmm2
movsd  0x18(%r15,%rdx,8),%xmm0
mulsd  (%rcx,%rdx,8),%xmm0
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm0
add    $0x4,%rdx
cmp    %rdx,%rsi
jne    1660 <trstep+0x4f0>
mov    %rax,%rsi
imul   %r9,%rsi
test   $0x3,%al
je     1600 <trstep+0x490>
mov    %eax,%ebp
and    $0x3,%ebp
lea    (%rdx,%r10,1),%rdi
mov    0x10(%rsp),%rbx
lea    (%rbx,%rdi,8),%rbx
lea    (%r15,%rdx,8),%rdx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rdx,%rdi,8),%xmm1
mulsd  (%rbx,%rdi,8),%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rdi
cmp    %rdi,%rbp
jne    16e0 <trstep+0x570>
jmp    1600 <trstep+0x490>
mov    %r15,%rdi
mov    0x8(%rsp),%rbp
mov    %ebp,%esi
call   1040 <l2norm@plt>
mov    %rbp,%rsi
movapd 0x191a(%rip),%xmm1
xorpd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
divsd  0x40(%rsp),%xmm1
movapd %xmm1,0x100(%rsp)
mov    0x28(%rsp),%r8
mov    0x48(%rsp),%rax
movapd 0x80(%rsp),%xmm4
mov    %r12,%r10
xorpd  0x18e5(%rip),%xmm4
test   %esi,%esi
jle    18be <trstep+0x74e>
mov    %esi,%r9d
cmp    $0x1,%esi
jne    1762 <trstep+0x5f2>
xor    %ecx,%ecx
jmp    1860 <trstep+0x6f0>
lea    (%r14,%r9,8),%rcx
lea    (%rax,%r9,8),%rdx
cmp    %rdx,%r14
setb   %dil
cmp    %rax,%rcx
seta   %bl
lea    (%r8,%r9,8),%rdx
cmp    %rdx,%r14
setb   %dl
cmp    %r8,%rcx
seta   %r8b
xor    %ecx,%ecx
test   %bl,%dil
jne    1856 <trstep+0x6e6>
and    %r8b,%dl
mov    0x30(%rsp),%rbx
mov    0x28(%rsp),%r8
jne    1860 <trstep+0x6f0>
mov    %r9d,%ecx
and    $0xfffffffe,%ecx
lea    -0x2(%rcx),%rdi
mov    %rdi,%rdx
shr    %rdx
add    $0x1,%rdx
test   %rdi,%rdi
je     246d <trstep+0x12fd>
mov    %rdx,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %ebp,%ebp
nopl   0x0(%rax)
movupd (%rax,%rbp,8),%xmm0
movupd (%r8,%rbp,8),%xmm1
divpd  %xmm1,%xmm0
movupd %xmm0,(%r14,%rbp,8)
movupd 0x10(%rax,%rbp,8),%xmm0
movupd 0x10(%r8,%rbp,8),%xmm1
divpd  %xmm1,%xmm0
movupd %xmm0,0x10(%r14,%rbp,8)
add    $0x4,%rbp
add    $0xfffffffffffffffe,%rdi
jne    17d0 <trstep+0x660>
test   $0x1,%dl
je     1821 <trstep+0x6b1>
movupd (%rax,%rbp,8),%xmm0
movupd (%r8,%rbp,8),%xmm1
divpd  %xmm1,%xmm0
movupd %xmm0,(%r14,%rbp,8)
cmp    %r9,%rcx
jne    1860 <trstep+0x6f0>
jmp    18be <trstep+0x74e>
mov    %r8d,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0xc,%rdi
jae    234b <trstep+0x11db>
xor    %edi,%edi
jmp    23c4 <trstep+0x1254>
mov    0x30(%rsp),%rbx
mov    0x28(%rsp),%r8
mov    %rcx,%rdx
not    %rdx
test   $0x1,%r9b
je     1881 <trstep+0x711>
movsd  (%rax,%rcx,8),%xmm0
divsd  (%r8,%rcx,8),%xmm0
movsd  %xmm0,(%r14,%rcx,8)
or     $0x1,%rcx
add    %r9,%rdx
je     18be <trstep+0x74e>
cs nopw 0x0(%rax,%rax,1)
movsd  (%rax,%rcx,8),%xmm0
divsd  (%r8,%rcx,8),%xmm0
movsd  %xmm0,(%r14,%rcx,8)
movsd  0x8(%rax,%rcx,8),%xmm0
divsd  0x8(%r8,%rcx,8),%xmm0
movsd  %xmm0,0x8(%r14,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%r9
jne    1890 <trstep+0x720>
mov    %r10,0x98(%rsp)
divsd  0x100(%rsp),%xmm4
movapd %xmm4,0x80(%rsp)
mov    %r14,%rdi
call   1040 <l2norm@plt>
movapd 0x80(%rsp),%xmm1
mov    0x28(%rsp),%r8
mov    0x8(%rsp),%rsi
movsd  0x38(%rsp),%xmm2
divsd  %xmm2,%xmm0
movsd  0x170b(%rip),%xmm3
movsd  %xmm0,0x78(%rsp)
mulsd  %xmm0,%xmm3
movsd  %xmm3,0x118(%rsp)
movsd  0x16f8(%rip),%xmm0
mulsd  %xmm2,%xmm0
movsd  %xmm0,0x120(%rsp)
movslq %esi,%r9
mov    %esi,%ebp
lea    (%r14,%rbp,8),%r10
lea    (%r8,%rbp,8),%r11
lea    (%rbx,%rbp,8),%rdx
mov    %ebp,%edi
and    $0xfffffffc,%edi
mov    %rdi,0xb8(%rsp)
add    $0xfffffffffffffffc,%rdi
mov    %rdi,0xb0(%rsp)
shr    $0x2,%rdi
add    $0x1,%rdi
cmp    %rdx,%r14
setb   %dl
cmp    %rbx,%r10
seta   %al
lea    -0x1(%rbp),%rcx
mov    %rcx,0xd0(%rsp)
and    %dl,%al
cmp    %r11,%r14
setb   %cl
cmp    %r8,%r10
seta   %dl
and    %cl,%dl
mov    %dl,0x1e(%rsp)
or     %dl,%al
mov    %al,0x1f(%rsp)
mov    %rdi,%rax
mov    %rdi,0xa8(%rsp)
and    %rdi,0x68(%rsp)
mov    %ebp,%eax
and    $0x3,%eax
mov    %rax,0xc0(%rsp)
lea    (%rsi,%rsi,1),%r12d
lea    0x8(%r8),%rax
mov    %rax,0xc8(%rsp)
mov    %rbp,0x20(%rsp)
mov    %ebp,%r11d
and    $0xfffffffe,%r11d
neg    %r11
mov    0x10(%rsp),%rdx
lea    (%rdx,%r9,8),%rax
add    $0x18,%rax
mov    %rax,0x110(%rsp)
mov    %r9,0x40(%rsp)
lea    0x0(,%r9,8),%rax
mov    %rax,0xf0(%rsp)
xorpd  %xmm4,%xmm4
movapd 0x50(%rsp),%xmm0
mov    %r11,0x70(%rsp)
cs nopw 0x0(%rax,%rax,1)
ucomisd %xmm0,%xmm1
movapd %xmm1,0x80(%rsp)
ja     1a27 <trstep+0x8b7>
ucomisd 0x78(%rsp),%xmm0
jbe    1a5d <trstep+0x8ed>
movsd  0x78(%rsp),%xmm0
mulsd  %xmm1,%xmm0
ucomisd %xmm4,%xmm0
jb     1a40 <trstep+0x8d0>
sqrtsd %xmm0,%xmm0
jmp    1a54 <trstep+0x8e4>
nopl   (%rax)
call   1090 <sqrt@plt>
mov    0x70(%rsp),%r11
mov    0x10(%rsp),%rdx
mov    0x8(%rsp),%rsi
maxsd  0x118(%rsp),%xmm0
test   %esi,%esi
movapd %xmm0,0x50(%rsp)
jle    1cc0 <trstep+0xb50>
cmpq   $0x0,0xd0(%rsp)
je     1f80 <trstep+0xe10>
xor    %r8d,%r8d
mov    $0x1,%r10d
mov    %esi,%ecx
mov    0xc8(%rsp),%rbx
xor    %edi,%edi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movslq %ecx,%rcx
lea    (%r10,%rcx,1),%r9
movslq %edi,%rdi
lea    (%rdi,%rbp,1),%rax
movsd  -0x8(%rbx),%xmm2
movapd %xmm0,%xmm1
mulsd  %xmm2,%xmm1
mulsd  %xmm2,%xmm1
addsd  0x0(%r13,%rax,8),%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
movsd  (%rbx),%xmm2
movapd %xmm0,%xmm1
mulsd  %xmm2,%xmm1
mulsd  %xmm2,%xmm1
addsd  0x0(%r13,%r9,8),%xmm1
movsd  %xmm1,0x0(%r13,%r9,8)
add    $0x2,%rbp
add    %r12d,%edi
add    $0x10,%rbx
add    $0x2,%r10
add    %r12d,%ecx
add    $0xfffffffffffffffe,%r8
cmp    %r8,%r11
jne    1aa0 <trstep+0x930>
neg    %r8
mov    0x30(%rsp),%rbx
testb  $0x1,0x20(%rsp)
je     1b45 <trstep+0x9d5>
mov    %r8d,%eax
imul   %esi,%eax
mov    0x28(%rsp),%rcx
movsd  (%rcx,%r8,8),%xmm2
movapd %xmm0,%xmm1
mulsd  %xmm2,%xmm1
cltq
add    %r8,%rax
mulsd  %xmm2,%xmm1
addsd  0x0(%r13,%rax,8),%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
xorpd  %xmm1,%xmm1
mov    %r13,%rdi
movsd  0xd8(%rsp),%xmm0
call   1060 <cholmod@plt>
mov    0x48(%rsp),%rbp
mov    %rbp,%rdi
mov    $0x1,%esi
mov    0x8(%rsp),%rdx
movsd  0x14ac(%rip),%xmm0
call   1080 <scale@plt>
mov    0x10(%rsp),%rdi
mov    0x8(%rsp),%rsi
mov    %rbp,%rdx
mov    %rbx,%rcx
call   1050 <linsolve_lower@plt>
mov    %rbp,%rdi
mov    $0x1,%esi
mov    0x8(%rsp),%rdx
movsd  0x147d(%rip),%xmm0
call   1080 <scale@plt>
mov    0x8(%rsp),%rsi
test   %esi,%esi
jle    1d28 <trstep+0xbb8>
movapd 0x50(%rsp),%xmm0
xorpd  0x146d(%rip),%xmm0
cmpq   $0x0,0xd0(%rsp)
je     1f93 <trstep+0xe23>
xor    %r8d,%r8d
mov    $0x1,%ecx
mov    %esi,%edx
mov    0xc8(%rsp),%rbx
xor    %edi,%edi
xor    %ebp,%ebp
mov    0x70(%rsp),%r10
nopl   (%rax)
movslq %edx,%rdx
lea    (%rcx,%rdx,1),%r9
movslq %edi,%rdi
lea    (%rdi,%rbp,1),%rax
movsd  -0x8(%rbx),%xmm1
movapd %xmm1,%xmm2
mulsd  %xmm0,%xmm2
mulsd  %xmm1,%xmm2
addsd  0x0(%r13,%rax,8),%xmm2
movsd  %xmm2,0x0(%r13,%rax,8)
movsd  (%rbx),%xmm1
movapd %xmm1,%xmm2
mulsd  %xmm0,%xmm2
mulsd  %xmm1,%xmm2
addsd  0x0(%r13,%r9,8),%xmm2
movsd  %xmm2,0x0(%r13,%r9,8)
add    $0x2,%rbp
add    %r12d,%edi
add    $0x10,%rbx
add    $0x2,%rcx
add    %r12d,%edx
add    $0xfffffffffffffffe,%r8
cmp    %r8,%r10
jne    1bf0 <trstep+0xa80>
neg    %r8
mov    0x30(%rsp),%rbx
testb  $0x1,0x20(%rsp)
je     1c92 <trstep+0xb22>
mov    %r8d,%ecx
imul   %esi,%ecx
mov    0x28(%rsp),%rax
movsd  (%rax,%r8,8),%xmm1
movslq %ecx,%rcx
add    %r8,%rcx
mulsd  %xmm1,%xmm0
mulsd  %xmm1,%xmm0
addsd  0x0(%r13,%rcx,8),%xmm0
movsd  %xmm0,0x0(%r13,%rcx,8)
test   %esi,%esi
jle    1d28 <trstep+0xbb8>
cmp    $0x4,%esi
setb   %al
or     0x1f(%rsp),%al
je     1fa6 <trstep+0xe36>
xor    %eax,%eax
mov    0x28(%rsp),%rdi
mov    0x20(%rsp),%rdx
jmp    207c <trstep+0xf0c>
nopl   0x0(%rax,%rax,1)
xorpd  %xmm1,%xmm1
mov    %r13,%rdi
movsd  0xd8(%rsp),%xmm0
call   1060 <cholmod@plt>
mov    0x48(%rsp),%rbp
mov    %rbp,%rdi
mov    $0x1,%esi
mov    0x8(%rsp),%rdx
movsd  0x1331(%rip),%xmm0
call   1080 <scale@plt>
mov    0x10(%rsp),%rdi
mov    0x8(%rsp),%rsi
mov    %rbp,%rdx
mov    %rbx,%rcx
call   1050 <linsolve_lower@plt>
mov    %rbp,%rdi
mov    $0x1,%esi
mov    0x8(%rsp),%rdx
movsd  0x1302(%rip),%xmm0
call   1080 <scale@plt>
mov    0x8(%rsp),%rsi
mov    %r14,%rdi
call   1040 <l2norm@plt>
mov    0x8(%rsp),%rsi
movapd %xmm0,%xmm5
movsd  0x38(%rsp),%xmm4
mov    0x10(%rsp),%r11
movsd  (%r14),%xmm0
divsd  (%r11),%xmm0
movsd  %xmm0,(%r15)
cmp    $0x2,%esi
jl     1e80 <trstep+0xd10>
mov    $0x1,%r10d
mov    0x40(%rsp),%r8
mov    0x110(%rsp),%rdx
xor    %r9d,%r9d
jmp    1db9 <trstep+0xc49>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%r14,%r10,8),%xmm1
subsd  %xmm0,%xmm1
add    %r10,%rax
divsd  (%r11,%rax,8),%xmm1
movsd  %xmm1,(%r15,%r10,8)
add    $0x1,%r10
add    $0x1,%r9
add    0xf0(%rsp),%rdx
add    0x40(%rsp),%r8
cmp    0x20(%rsp),%r10
je     1e80 <trstep+0xd10>
cmp    $0x3,%r9
jae    1dd0 <trstep+0xc60>
xorpd  %xmm0,%xmm0
xor    %edi,%edi
jmp    1e2b <trstep+0xcbb>
nopw   0x0(%rax,%rax,1)
mov    %r10,%rax
and    $0xfffffffffffffffc,%rax
xorpd  %xmm0,%xmm0
xor    %edi,%edi
nopl   (%rax)
movsd  (%r15,%rdi,8),%xmm1
movsd  0x8(%r15,%rdi,8),%xmm2
mulsd  -0x18(%rdx,%rdi,8),%xmm1
mulsd  -0x10(%rdx,%rdi,8),%xmm2
addsd  %xmm0,%xmm1
movsd  0x10(%r15,%rdi,8),%xmm3
mulsd  -0x8(%rdx,%rdi,8),%xmm3
addsd  %xmm1,%xmm2
movsd  0x18(%r15,%rdi,8),%xmm0
mulsd  (%rdx,%rdi,8),%xmm0
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm0
add    $0x4,%rdi
cmp    %rdi,%rax
jne    1de0 <trstep+0xc70>
mov    %r10,%rax
imul   0x40(%rsp),%rax
test   $0x3,%r10b
je     1d80 <trstep+0xc10>
mov    %r10d,%ebp
and    $0x3,%ebp
lea    (%rdi,%r8,1),%rcx
lea    (%r11,%rcx,8),%rcx
lea    (%r15,%rdi,8),%rdi
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rdi,%rbx,8),%xmm1
mulsd  (%rcx,%rbx,8),%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rbx
cmp    %rbx,%rbp
jne    1e60 <trstep+0xcf0>
jmp    1d80 <trstep+0xc10>
nopl   0x0(%rax)
movapd %xmm5,%xmm0
subsd  %xmm4,%xmm0
movapd %xmm0,0xe0(%rsp)
mov    %r15,%rdi
movsd  %xmm5,0x130(%rsp)
call   1040 <l2norm@plt>
movsd  0x130(%rsp),%xmm5
movapd %xmm0,%xmm7
xorpd  0x1179(%rip),%xmm7
mulsd  %xmm0,%xmm7
divsd  %xmm5,%xmm7
ucomisd 0x120(%rsp),%xmm5
setae  %al
movsd  0x128(%rsp),%xmm0
ucomisd %xmm5,%xmm0
setae  %cl
test   %cl,%al
jne    231f <trstep+0x11af>
movsd  0x78(%rsp),%xmm0
movapd 0x80(%rsp),%xmm3
subsd  %xmm3,%xmm0
xorpd  %xmm4,%xmm4
ucomisd %xmm4,%xmm0
movapd 0x50(%rsp),%xmm0
jae    2338 <trstep+0x11c8>
movapd 0xe0(%rsp),%xmm6
movapd %xmm6,%xmm2
divsd  %xmm7,%xmm2
movapd %xmm0,%xmm1
subsd  %xmm2,%xmm1
movapd %xmm3,%xmm2
cmplesd %xmm1,%xmm2
andpd  %xmm2,%xmm1
andnpd %xmm3,%xmm2
orpd   %xmm1,%xmm2
mulsd  %xmm6,%xmm5
cmpltsd %xmm4,%xmm6
movapd %xmm6,%xmm1
andnpd %xmm2,%xmm1
andpd  %xmm0,%xmm6
orpd   %xmm1,%xmm6
mulsd  0x38(%rsp),%xmm7
divsd  %xmm7,%xmm5
subsd  %xmm5,%xmm0
movapd %xmm6,%xmm1
mov    0x30(%rsp),%rbx
mov    0x8(%rsp),%rsi
mov    0x10(%rsp),%rdx
mov    0x70(%rsp),%r11
jmp    1a10 <trstep+0x8a0>
nopl   0x0(%rax)
xor    %r8d,%r8d
testb  $0x1,0x20(%rsp)
jne    1b15 <trstep+0x9a5>
jmp    1b45 <trstep+0x9d5>
xor    %r8d,%r8d
testb  $0x1,0x20(%rsp)
jne    1c65 <trstep+0xaf5>
jmp    1c92 <trstep+0xb22>
cmpq   $0x0,0xb0(%rsp)
mov    0x28(%rsp),%rdi
mov    0x20(%rsp),%rdx
je     22eb <trstep+0x117b>
mov    0x68(%rsp),%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
movupd (%rbx,%rax,8),%xmm0
movupd 0x10(%rbx,%rax,8),%xmm1
movupd (%rdi,%rax,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rdi,%rax,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,(%r14,%rax,8)
movupd %xmm0,0x10(%r14,%rax,8)
movupd 0x20(%rbx,%rax,8),%xmm0
movupd 0x30(%rbx,%rax,8),%xmm1
movupd 0x20(%rdi,%rax,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x30(%rdi,%rax,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,0x20(%r14,%rax,8)
movupd %xmm0,0x30(%r14,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    1fd0 <trstep+0xe60>
testb  $0x1,0xa8(%rsp)
01
je     2068 <trstep+0xef8>
movupd (%rbx,%rax,8),%xmm0
movupd 0x10(%rbx,%rax,8),%xmm1
movupd (%rdi,%rax,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rdi,%rax,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,(%r14,%rax,8)
movupd %xmm0,0x10(%r14,%rax,8)
mov    0xb8(%rsp),%rcx
mov    %rcx,%rax
cmp    %rdx,%rcx
je     2122 <trstep+0xfb2>
mov    %rax,%rcx
not    %rcx
add    %rdx,%rcx
mov    0xc0(%rsp),%rdx
test   %rdx,%rdx
je     20ba <trstep+0xf4a>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rbx,%rax,8),%xmm0
mulsd  (%rdi,%rax,8),%xmm0
movsd  %xmm0,(%r14,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    20a0 <trstep+0xf30>
cmp    $0x3,%rcx
mov    0x20(%rsp),%rcx
jb     2122 <trstep+0xfb2>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rbx,%rax,8),%xmm0
mulsd  (%rdi,%rax,8),%xmm0
movsd  %xmm0,(%r14,%rax,8)
movsd  0x8(%rbx,%rax,8),%xmm0
mulsd  0x8(%rdi,%rax,8),%xmm0
movsd  %xmm0,0x8(%r14,%rax,8)
movsd  0x10(%rbx,%rax,8),%xmm0
mulsd  0x10(%rdi,%rax,8),%xmm0
movsd  %xmm0,0x10(%r14,%rax,8)
movsd  0x18(%rbx,%rax,8),%xmm0
mulsd  0x18(%rdi,%rax,8),%xmm0
movsd  %xmm0,0x18(%r14,%rax,8)
add    $0x4,%rax
cmp    %rax,%rcx
jne    20d0 <trstep+0xf60>
mov    %r14,%rdi
call   1040 <l2norm@plt>
mov    0x8(%rsp),%rsi
movapd %xmm0,%xmm5
test   %esi,%esi
jle    1d39 <trstep+0xbc9>
cmp    $0x4,%esi
setb   %al
or     0x1e(%rsp),%al
movsd  0x38(%rsp),%xmm4
je     2163 <trstep+0xff3>
xor    %eax,%eax
mov    0x10(%rsp),%r11
mov    0x28(%rsp),%rdi
mov    0x20(%rsp),%rdx
jmp    2242 <trstep+0x10d2>
cmpq   $0x0,0xb0(%rsp)
mov    0x28(%rsp),%rdi
je     2300 <trstep+0x1190>
mov    0x68(%rsp),%rcx
xor    %eax,%eax
mov    0x10(%rsp),%r11
mov    0x20(%rsp),%rdx
nopl   0x0(%rax,%rax,1)
movupd (%rdi,%rax,8),%xmm0
movupd 0x10(%rdi,%rax,8),%xmm1
movupd (%r14,%rax,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%r14,%rax,8),%xmm0
mulpd  %xmm1,%xmm0
movupd 0x20(%r14,%rax,8),%xmm1
movupd 0x30(%r14,%rax,8),%xmm3
movupd %xmm2,(%r14,%rax,8)
movupd %xmm0,0x10(%r14,%rax,8)
movupd 0x20(%rdi,%rax,8),%xmm0
mulpd  %xmm1,%xmm0
movupd 0x30(%rdi,%rax,8),%xmm1
mulpd  %xmm3,%xmm1
movupd %xmm0,0x20(%r14,%rax,8)
movupd %xmm1,0x30(%r14,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    2190 <trstep+0x1020>
testb  $0x1,0xa8(%rsp)
01
je     222e <trstep+0x10be>
movupd (%rdi,%rax,8),%xmm0
movupd 0x10(%rdi,%rax,8),%xmm1
movupd (%r14,%rax,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%r14,%rax,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,(%r14,%rax,8)
movupd %xmm0,0x10(%r14,%rax,8)
mov    0xb8(%rsp),%rcx
mov    %rcx,%rax
cmp    %rdx,%rcx
je     1d44 <trstep+0xbd4>
mov    %rax,%rcx
not    %rcx
add    %rdx,%rcx
test   $0x3,%dl
je     227b <trstep+0x110b>
mov    0xc0(%rsp),%rdx
nopl   0x0(%rax,%rax,1)
movsd  (%rdi,%rax,8),%xmm0
mulsd  (%r14,%rax,8),%xmm0
movsd  %xmm0,(%r14,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    2260 <trstep+0x10f0>
cmp    $0x3,%rcx
jb     1d44 <trstep+0xbd4>
mov    0x20(%rsp),%rcx
nopw   0x0(%rax,%rax,1)
movsd  (%rdi,%rax,8),%xmm0
mulsd  (%r14,%rax,8),%xmm0
movsd  %xmm0,(%r14,%rax,8)
movsd  0x8(%rdi,%rax,8),%xmm0
mulsd  0x8(%r14,%rax,8),%xmm0
movsd  %xmm0,0x8(%r14,%rax,8)
movsd  0x10(%rdi,%rax,8),%xmm0
mulsd  0x10(%r14,%rax,8),%xmm0
movsd  %xmm0,0x10(%r14,%rax,8)
movsd  0x18(%rdi,%rax,8),%xmm0
mulsd  0x18(%r14,%rax,8),%xmm0
movsd  %xmm0,0x18(%r14,%rax,8)
add    $0x4,%rax
cmp    %rax,%rcx
jne    2290 <trstep+0x1120>
jmp    1d44 <trstep+0xbd4>
xor    %eax,%eax
testb  $0x1,0xa8(%rsp)
01
jne    203d <trstep+0xecd>
jmp    2068 <trstep+0xef8>
xor    %eax,%eax
mov    0x10(%rsp),%r11
mov    0x20(%rsp),%rdx
testb  $0x1,0xa8(%rsp)
01
jne    2201 <trstep+0x1091>
jmp    222e <trstep+0x10be>
movsd  0x38(%rsp),%xmm5
mov    0x98(%rsp),%rax
movapd 0x50(%rsp),%xmm0
jmp    2416 <trstep+0x12a6>
movsd  0x38(%rsp),%xmm5
mov    0x98(%rsp),%rax
jmp    2416 <trstep+0x12a6>
movabs $0x7ffffffffffffffe,%rdi
ff ff 7f
add    $0xfffffffffffffffe,%rdi
and    %rdi,%rsi
xor    %edi,%edi
xchg   %ax,%ax
movups (%r12,%rdi,8),%xmm0
movups 0x10(%r12,%rdi,8),%xmm1
movups %xmm0,(%rbx,%rdi,8)
movups %xmm1,0x10(%rbx,%rdi,8)
movups 0x20(%r12,%rdi,8),%xmm0
movups 0x30(%r12,%rdi,8),%xmm1
movups %xmm0,0x20(%rbx,%rdi,8)
movups %xmm1,0x30(%rbx,%rdi,8)
movups 0x40(%r12,%rdi,8),%xmm0
movups 0x50(%r12,%rdi,8),%xmm1
movups %xmm0,0x40(%rbx,%rdi,8)
movups %xmm1,0x50(%rbx,%rdi,8)
movupd 0x60(%r12,%rdi,8),%xmm0
movupd 0x70(%r12,%rdi,8),%xmm1
movupd %xmm0,0x60(%rbx,%rdi,8)
movupd %xmm1,0x70(%rbx,%rdi,8)
add    $0x10,%rdi
add    $0xfffffffffffffffc,%rsi
jne    2360 <trstep+0x11f0>
test   %rdx,%rdx
je     23ff <trstep+0x128f>
lea    (%rbx,%rdi,8),%rsi
add    $0x10,%rsi
lea    (%r12,%rdi,8),%rdi
add    $0x10,%rdi
shl    $0x5,%rdx
xor    %ebp,%ebp
nop
movupd -0x10(%rdi,%rbp,1),%xmm0
movupd (%rdi,%rbp,1),%xmm1
movupd %xmm0,-0x10(%rsi,%rbp,1)
movupd %xmm1,(%rsi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rdx
jne    23e0 <trstep+0x1270>
cmp    %r8,%rcx
jne    13f1 <trstep+0x281>
xorpd  %xmm0,%xmm0
ucomisd %xmm5,%xmm2
ja     2416 <trstep+0x12a6>
movapd %xmm2,%xmm5
movsd  %xmm5,(%rax)
movsd  %xmm0,0x8(%rax)
movsd  0xa0(%rsp),%xmm0
movsd  %xmm0,0x10(%rax)
movaps 0xe0(%rsp),%xmm0
movsd  %xmm0,0x18(%rax)
movsd  %xmm7,0x20(%rax)
movaps 0x100(%rsp),%xmm0
movsd  %xmm0,0x28(%rax)
mov    %r14,%rdi
call   1030 <free@plt>
mov    %r15,%rdi
add    $0x138,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>
xor    %ebp,%ebp
test   $0x1,%dl
jne    180c <trstep+0x69c>
jmp    1821 <trstep+0x6b1>
mov    0x30(%rsp),%rbx
jmp    1327 <trstep+0x1b7>
xor    %eax,%eax
test   $0x1,%dl
jne    1580 <trstep+0x410>
jmp    15b7 <trstep+0x447>

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

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