void trstep(double *jac, double *sN, int N, double *dx, double *L, double *hess,
            double nlen, double *ioval, 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, 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  0xe61(%rip),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  0xe4c(%rip),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    0x10(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    0x10(%rbp),%rax
movsd  0x20(%rax),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    0x10(%rbp),%rax
movsd  0x28(%rax),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movslq -0x14(%rbp),%rdi
shl    $0x3,%rdi
call   1070 <malloc@plt>
mov    %rax,-0xd0(%rbp)
movslq -0x14(%rbp),%rdi
shl    $0x3,%rdi
call   1070 <malloc@plt>
mov    %rax,-0xd8(%rbp)
movsd  -0x38(%rbp),%xmm1
movsd  -0x80(%rbp),%xmm0
mulsd  -0xa0(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jb     12e1 <trstep+0x171>
mov    0x10(%rbp),%rax
movsd  0xd9f(%rip),%xmm0
movsd  %xmm0,0x30(%rax)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12b1 <trstep+0x141>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    127d <trstep+0x10d>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
ucomisd -0x38(%rbp),%xmm0
jbe    12dc <trstep+0x16c>
movsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
jmp    1ab3 <trstep+0x943>
mov    0x10(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x30(%rax)
movsd  -0xa8(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1356 <trstep+0x1e6>
movsd  -0xb8(%rbp),%xmm1
ff
addsd  -0xb0(%rbp),%xmm1
ff
movsd  -0xb0(%rbp),%xmm0
ff
subsd  -0xa0(%rbp),%xmm0
ff
addsd  -0xb8(%rbp),%xmm0
ff
mulsd  %xmm0,%xmm1
movsd  -0xa0(%rbp),%xmm0
ff
mulsd  -0xc0(%rbp),%xmm0
ff
divsd  %xmm0,%xmm1
movsd  -0xa8(%rbp),%xmm0
ff
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x38(%rbp),%xmm0
subsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0xb8(%rbp)
ff
mov    0x10(%rbp),%rax
movsd  0x38(%rax),%xmm0
movsd  0xc94(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    1515 <trstep+0x3a5>
jp     1515 <trstep+0x3a5>
mov    0x10(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x38(%rax)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    13f0 <trstep+0x280>
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0xd0(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    139f <trstep+0x22f>
mov    -0xd0(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x28(%rbp),%rax
divsd  (%rax),%xmm0
mov    -0xd8(%rbp),%rax
movsd  %xmm0,(%rax)
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    14cd <trstep+0x35d>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x3c(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    %eax,-0x40(%rbp)
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    1488 <trstep+0x318>
mov    -0xd8(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    143a <trstep+0x2ca>
mov    -0xd0(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x50(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    -0xd8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1415 <trstep+0x2a5>
mov    -0xd8(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    $0x0,%al
call   1040 <l2norm@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x58(%rbp),%xmm0
divsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
divsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    158f <trstep+0x41f>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    -0xd0(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    154b <trstep+0x3db>
mov    -0xd0(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    $0x0,%al
call   1040 <l2norm@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
divsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
movl   $0x0,-0x44(%rbp)
cmpl   $0x0,-0x44(%rbp)
jne    1aae <trstep+0x93e>
movsd  -0xa8(%rbp),%xmm1
ff
movsd  -0x90(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
ja     15ff <trstep+0x48f>
movsd  -0xa8(%rbp),%xmm0
ff
ucomisd -0x98(%rbp),%xmm0
ff
jbe    1662 <trstep+0x4f2>
movsd  -0x90(%rbp),%xmm0
ff
mulsd  -0x98(%rbp),%xmm0
ff
call   1090 <sqrt@plt>
movsd  %xmm0,-0x60(%rbp)
movsd  0x9f7(%rip),%xmm0
mulsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x68(%rbp)
movsd  -0x60(%rbp),%xmm0
ucomisd -0x68(%rbp),%xmm0
jbe    1650 <trstep+0x4e0>
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
jmp    165d <trstep+0x4ed>
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
jmp    1662 <trstep+0x4f2>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    16ce <trstep+0x55e>
mov    -0x3c(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    %eax,-0x40(%rbp)
movsd  -0xa8(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x30(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1669 <trstep+0x4f9>
mov    -0x30(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x28(%rbp),%rdx
xorps  %xmm0,%xmm0
mov    $0x1,%al
call   1060 <cholmod@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%edx
mov    $0x1,%esi
movsd  0x920(%rip),%xmm0
mov    $0x1,%al
call   1080 <scale@plt>
mov    -0x28(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x8(%rbp),%rdx
mov    0x18(%rbp),%rcx
mov    $0x0,%al
call   1050 <linsolve_lower@plt>
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%edx
mov    $0x1,%esi
movsd  0x8ef(%rip),%xmm0
mov    $0x1,%al
call   1080 <scale@plt>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    17bb <trstep+0x64b>
mov    -0x3c(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    %eax,-0x40(%rbp)
movsd  -0xa8(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x30(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    -0x3c(%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    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    173f <trstep+0x5cf>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1806 <trstep+0x696>
mov    0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0xd0(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    17c2 <trstep+0x652>
mov    -0xd0(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    $0x0,%al
call   1040 <l2norm@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
subsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0xb8(%rbp)
ff
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1878 <trstep+0x708>
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xd0(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    183c <trstep+0x6cc>
mov    -0xd0(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x28(%rbp),%rax
divsd  (%rax),%xmm0
mov    -0xd8(%rbp),%rax
movsd  %xmm0,(%rax)
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1955 <trstep+0x7e5>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x3c(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    %eax,-0x40(%rbp)
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    1910 <trstep+0x7a0>
mov    -0xd8(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    18c2 <trstep+0x752>
mov    -0xd0(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x50(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    -0xd8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    189d <trstep+0x72d>
mov    -0xd8(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    $0x0,%al
call   1040 <l2norm@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x58(%rbp),%xmm0
divsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
movsd  -0x88(%rbp),%xmm1
ff
mulsd  -0xa0(%rbp),%xmm1
ff
ucomisd %xmm1,%xmm0
jb     19d8 <trstep+0x868>
movsd  -0x78(%rbp),%xmm1
movsd  -0x80(%rbp),%xmm0
mulsd  -0xa0(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jae    19f5 <trstep+0x885>
movsd  -0x98(%rbp),%xmm0
ff
subsd  -0x90(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1a01 <trstep+0x891>
movl   $0x1,-0x44(%rbp)
jmp    1aa9 <trstep+0x939>
movsd  -0x90(%rbp),%xmm1
ff
movsd  -0xa8(%rbp),%xmm0
ff
movsd  -0xb8(%rbp),%xmm2
ff
divsd  -0xc0(%rbp),%xmm2
ff
subsd  %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jb     1a53 <trstep+0x8e3>
movsd  -0xa8(%rbp),%xmm0
ff
movsd  -0xb8(%rbp),%xmm1
ff
divsd  -0xc0(%rbp),%xmm1
ff
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
xorps  %xmm0,%xmm0
ucomisd -0xb8(%rbp),%xmm0
ff
jbe    1a74 <trstep+0x904>
movsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x78(%rbp),%xmm1
mulsd  -0xb8(%rbp),%xmm1
ff
movsd  -0xa0(%rbp),%xmm0
ff
mulsd  -0xc0(%rbp),%xmm0
ff
divsd  %xmm0,%xmm1
movsd  -0xa8(%rbp),%xmm0
ff
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
jmp    15c5 <trstep+0x455>
jmp    1ab3 <trstep+0x943>
movsd  -0xa0(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0xa8(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0xb0(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movsd  -0xb8(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movsd  %xmm0,0x18(%rax)
movsd  -0xc0(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movsd  %xmm0,0x20(%rax)
movsd  -0xc8(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movsd  %xmm0,0x28(%rax)
mov    -0xd0(%rbp),%rdi
call   1030 <free@plt>
mov    -0xd8(%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    $0xf8,%rsp
movsd  %xmm0,0x8(%rsp)
mov    %r9,%r13
mov    %r8,0x10(%rsp)
mov    %rcx,(%rsp)
mov    %edx,%r15d
mov    %rsi,0x18(%rsp)
mov    %rdi,0x40(%rsp)
mov    0x138(%rsp),%rax
mov    %rax,0x30(%rsp)
mov    0x130(%rsp),%rbp
movsd  0x0(%rbp),%xmm0
movsd  %xmm0,0x20(%rsp)
movsd  0x8(%rbp),%xmm0
movaps %xmm0,0x60(%rsp)
movsd  0x10(%rbp),%xmm0
movsd  %xmm0,0x88(%rsp)
movsd  0x18(%rbp),%xmm0
movsd  %xmm0,0x38(%rsp)
movsd  0x20(%rbp),%xmm0
movaps %xmm0,0x50(%rsp)
movsd  0x28(%rbp),%xmm0
movaps %xmm0,0xc0(%rsp)
movslq %edx,%rax
mov    %rax,0x28(%rsp)
lea    0x0(,%rax,8),%rbx
mov    %rbx,%rdi
call   1070 <malloc@plt>
mov    %rax,%r14
mov    %rbx,0xb8(%rsp)
mov    %rbx,%rdi
call   1070 <malloc@plt>
movsd  0x8(%rsp),%xmm5
movsd  0x20(%rsp),%xmm2
mov    %rax,%r12
movsd  0x1dc4(%rip),%xmm0
mulsd  %xmm2,%xmm0
movsd  %xmm0,0xe8(%rsp)
ucomisd %xmm5,%xmm0
jae    1325 <trstep+0x1b5>
movq   $0x0,0x30(%rbp)
xorpd  %xmm0,%xmm0
movapd 0x60(%rsp),%xmm3
ucomisd %xmm0,%xmm3
mov    %rbp,%r9
jbe    12a3 <trstep+0x133>
movsd  0x88(%rsp),%xmm1
movapd %xmm1,%xmm0
movsd  0x38(%rsp),%xmm4
addsd  %xmm4,%xmm0
subsd  %xmm2,%xmm1
addsd  %xmm4,%xmm1
mulsd  %xmm0,%xmm1
movapd 0x50(%rsp),%xmm0
mulsd  %xmm2,%xmm0
divsd  %xmm0,%xmm1
subsd  %xmm1,%xmm3
mov    (%rsp),%rbx
mov    0x40(%rsp),%rbp
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
mov    %rax,0x70(%rsp)
movapd %xmm5,%xmm4
subsd  %xmm2,%xmm4
movsd  0x38(%r9),%xmm0
ucomisd 0x1d37(%rip),%xmm0
mov    %r15,0x48(%rsp)
mov    %r9,0x80(%rsp)
movapd %xmm3,0x60(%rsp)
jne    16a4 <trstep+0x534>
jp     16a4 <trstep+0x534>
movq   $0x0,0x38(%r9)
test   %r15d,%r15d
mov    0x10(%rsp),%r11
movapd %xmm4,0x50(%rsp)
jle    13fd <trstep+0x28d>
mov    %r15d,%r8d
cmp    $0x4,%r15d
jae    1410 <trstep+0x2a0>
xor    %ecx,%ecx
mov    0x18(%rsp),%rbp
jmp    1510 <trstep+0x3a0>
movabs $0x3ff0000000000000,%rax
mov    %rax,0x30(%rbp)
test   %r15d,%r15d
mov    0x30(%rsp),%rbx
mov    %rbp,%rax
mov    0x18(%rsp),%rbp
movsd  0x38(%rsp),%xmm3
movapd 0x50(%rsp),%xmm6
jle    217d <trstep+0x100d>
mov    %r15d,%r8d
cmp    $0x4,%r15d
jb     137f <trstep+0x20f>
lea    0x0(,%r8,8),%rcx
add    %rbp,%rcx
cmp    %rbx,%rcx
jbe    2074 <trstep+0xf04>
lea    (%rbx,%r8,8),%rcx
cmp    %rbp,%rcx
jbe    2074 <trstep+0xf04>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %r8,%rdx
mov    %r8,%rsi
and    $0x3,%rsi
je     13b5 <trstep+0x245>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  0x0(%rbp,%rcx,8),%xmm0
movsd  %xmm0,(%rbx,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    13a0 <trstep+0x230>
cmp    $0x3,%rdx
jb     217d <trstep+0x100d>
nop
movsd  0x0(%rbp,%rcx,8),%xmm0
movsd  %xmm0,(%rbx,%rcx,8)
movsd  0x8(%rbp,%rcx,8),%xmm0
movsd  %xmm0,0x8(%rbx,%rcx,8)
movsd  0x10(%rbp,%rcx,8),%xmm0
movsd  %xmm0,0x10(%rbx,%rcx,8)
movsd  0x18(%rbp,%rcx,8),%xmm0
movsd  %xmm0,0x18(%rbx,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%r8
jne    13c0 <trstep+0x250>
jmp    217d <trstep+0x100d>
movabs $0x7ff8000000000000,%rax
mov    %rax,(%r12)
jmp    165d <trstep+0x4ed>
mov    %r8d,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rax
mov    %rax,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
test   %rax,%rax
mov    0x18(%rsp),%rbp
je     20ab <trstep+0xf3b>
mov    %rsi,%rdi
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
and    %rax,%rdi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nop
movupd (%rbx,%rdx,8),%xmm0
movupd 0x10(%rbx,%rdx,8),%xmm1
mulpd  %xmm0,%xmm0
mulpd  %xmm1,%xmm1
movupd 0x0(%rbp,%rdx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rbp,%rdx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,(%r14,%rdx,8)
movupd %xmm0,0x10(%r14,%rdx,8)
movupd 0x20(%rbx,%rdx,8),%xmm0
movupd 0x30(%rbx,%rdx,8),%xmm1
mulpd  %xmm0,%xmm0
mulpd  %xmm1,%xmm1
movupd 0x20(%rbp,%rdx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x30(%rbp,%rdx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,0x20(%r14,%rdx,8)
movupd %xmm0,0x30(%r14,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rdi
jne    1450 <trstep+0x2e0>
test   $0x1,%sil
je     14fe <trstep+0x38e>
movupd (%rbx,%rdx,8),%xmm0
movupd 0x10(%rbx,%rdx,8),%xmm1
mulpd  %xmm0,%xmm0
mulpd  %xmm1,%xmm1
movupd 0x0(%rbp,%rdx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rbp,%rdx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,(%r14,%rdx,8)
movupd %xmm0,0x10(%r14,%rdx,8)
cmp    %r8,%rcx
je     152e <trstep+0x3be>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rbx,%rcx,8),%xmm0
mulsd  %xmm0,%xmm0
mulsd  0x0(%rbp,%rcx,8),%xmm0
movsd  %xmm0,(%r14,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%r8
jne    1510 <trstep+0x3a0>
movsd  (%r14),%xmm0
divsd  (%r11),%xmm0
movsd  %xmm0,(%r12)
cmp    $0x2,%r15d
jl     165d <trstep+0x4ed>
mov    0x28(%rsp),%r9
lea    (%r11,%r9,8),%rcx
add    $0x18,%rcx
mov    $0x1,%edi
xor    %r10d,%r10d
jmp    1597 <trstep+0x427>
nop
movsd  (%r14,%rdi,8),%xmm1
subsd  %xmm0,%xmm1
add    %rdi,%rdx
divsd  (%r11,%rdx,8),%xmm1
movsd  %xmm1,(%r12,%rdi,8)
add    $0x1,%rdi
add    $0x1,%r10
add    0xb8(%rsp),%rcx
add    0x28(%rsp),%r9
cmp    %r8,%rdi
je     165d <trstep+0x4ed>
cmp    $0x3,%r10
jae    15b0 <trstep+0x440>
xorpd  %xmm0,%xmm0
xor    %ebp,%ebp
jmp    160b <trstep+0x49b>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rdi,%rdx
and    $0xfffffffffffffffc,%rdx
xorpd  %xmm0,%xmm0
xor    %ebp,%ebp
nopl   (%rax)
movsd  (%r12,%rbp,8),%xmm1
movsd  0x8(%r12,%rbp,8),%xmm2
mulsd  -0x18(%rcx,%rbp,8),%xmm1
mulsd  -0x10(%rcx,%rbp,8),%xmm2
addsd  %xmm0,%xmm1
movsd  0x10(%r12,%rbp,8),%xmm3
mulsd  -0x8(%rcx,%rbp,8),%xmm3
addsd  %xmm1,%xmm2
movsd  0x18(%r12,%rbp,8),%xmm0
mulsd  (%rcx,%rbp,8),%xmm0
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm0
add    $0x4,%rbp
cmp    %rbp,%rdx
jne    15c0 <trstep+0x450>
mov    %rdi,%rdx
imul   0x28(%rsp),%rdx
test   $0x3,%dil
je     1560 <trstep+0x3f0>
mov    %edi,%eax
and    $0x3,%eax
lea    (%r9,%rbp,1),%rsi
lea    (%r11,%rsi,8),%rbx
lea    (%r12,%rbp,8),%rbp
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rsi,8),%xmm1
mulsd  (%rbx,%rsi,8),%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rsi
cmp    %rsi,%rax
jne    1640 <trstep+0x4d0>
jmp    1560 <trstep+0x3f0>
mov    %r12,%rdi
mov    0x48(%rsp),%r15
mov    %r15d,%esi
xor    %eax,%eax
call   1040 <l2norm@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movapd 0x19b2(%rip),%xmm1
xorpd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
divsd  0x8(%rsp),%xmm1
movapd %xmm1,0xc0(%rsp)
mov    (%rsp),%rbx
mov    0x40(%rsp),%rbp
movapd 0x50(%rsp),%xmm4
xorpd  0x1984(%rip),%xmm4
mov    %r15,%r8
test   %r15d,%r15d
jle    176a <trstep+0x5fa>
mov    %r8,%rcx
mov    %ecx,%eax
cmp    $0x1,%ecx
jne    16c9 <trstep+0x559>
xor    %ecx,%ecx
jmp    1750 <trstep+0x5e0>
mov    %eax,%ecx
and    $0xfffffffe,%ecx
lea    -0x2(%rcx),%rsi
mov    %rsi,%rdx
shr    %rdx
add    $0x1,%rdx
test   %rsi,%rsi
je     209b <trstep+0xf2b>
mov    %rdx,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %esi,%esi
xchg   %ax,%ax
movupd 0x0(%rbp,%rsi,8),%xmm0
movupd (%rbx,%rsi,8),%xmm1
divpd  %xmm1,%xmm0
movupd %xmm0,(%r14,%rsi,8)
movupd 0x10(%rbp,%rsi,8),%xmm0
movupd 0x10(%rbx,%rsi,8),%xmm1
divpd  %xmm1,%xmm0
movupd %xmm0,0x10(%r14,%rsi,8)
add    $0x4,%rsi
add    $0xfffffffffffffffe,%rdi
jne    16f0 <trstep+0x580>
test   $0x1,%dl
je     1740 <trstep+0x5d0>
movupd 0x0(%rbp,%rsi,8),%xmm0
movupd (%rbx,%rsi,8),%xmm1
divpd  %xmm1,%xmm0
movupd %xmm0,(%r14,%rsi,8)
cmp    %rax,%rcx
je     176a <trstep+0x5fa>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  0x0(%rbp,%rcx,8),%xmm0
divsd  (%rbx,%rcx,8),%xmm0
movsd  %xmm0,(%r14,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1750 <trstep+0x5e0>
divsd  0xc0(%rsp),%xmm4
movapd %xmm4,0x50(%rsp)
mov    %r14,%rdi
mov    %r8,%rbx
mov    %ebx,%esi
xor    %eax,%eax
call   1040 <l2norm@plt>
movapd 0x50(%rsp),%xmm3
mov    (%rsp),%r10
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
movsd  0x20(%rsp),%xmm0
divsd  %xmm0,%xmm1
movsd  0x1865(%rip),%xmm2
movsd  %xmm1,0x18(%rsp)
mulsd  %xmm1,%xmm2
movsd  %xmm2,0xd8(%rsp)
movsd  0x1852(%rip),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0xe0(%rsp)
mov    %ebx,%eax
lea    -0x1(%rax),%rcx
mov    %rcx,0xb0(%rsp)
mov    %eax,%ecx
and    $0xfffffffc,%ecx
mov    %rcx,0xa0(%rsp)
add    $0xfffffffffffffffc,%rcx
mov    %rcx,0x98(%rsp)
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %rcx,%rdx
mov    %rcx,0x90(%rsp)
and    %rcx,0x70(%rsp)
lea    (%rbx,%rbx,1),%r15d
lea    0x8(%r10),%rcx
mov    %rcx,0xa8(%rsp)
mov    %rax,0x8(%rsp)
mov    %eax,%r11d
and    $0xfffffffe,%r11d
neg    %r11
mov    0x10(%rsp),%rdx
mov    0x28(%rsp),%rax
lea    (%rdx,%rax,8),%rax
add    $0x18,%rax
mov    %rax,0xd0(%rsp)
xorpd  %xmm4,%xmm4
movapd 0x60(%rsp),%xmm0
mov    %r11,0x78(%rsp)
nopw   0x0(%rax,%rax,1)
ucomisd %xmm0,%xmm3
movapd %xmm3,0x50(%rsp)
ja     1874 <trstep+0x704>
ucomisd 0x18(%rsp),%xmm0
jbe    18ac <trstep+0x73c>
movsd  0x18(%rsp),%xmm0
mulsd  %xmm3,%xmm0
ucomisd %xmm4,%xmm0
jb     1890 <trstep+0x720>
sqrtsd %xmm0,%xmm0
jmp    18a3 <trstep+0x733>
nopw   0x0(%rax,%rax,1)
call   1090 <sqrt@plt>
mov    0x78(%rsp),%r11
mov    (%rsp),%r10
mov    0x10(%rsp),%rdx
maxsd  0xd8(%rsp),%xmm0
test   %ebx,%ebx
movapd %xmm0,0x60(%rsp)
jle    1af0 <trstep+0x980>
cmpq   $0x0,0xb0(%rsp)
je     1da0 <trstep+0xc30>
xor    %r8d,%r8d
mov    $0x1,%ecx
mov    0xa8(%rsp),%rsi
xor    %edi,%edi
xor    %ebp,%ebp
nopl   (%rax)
movslq %ebx,%rbx
lea    (%rcx,%rbx,1),%r9
movslq %edi,%rdi
lea    (%rdi,%rbp,1),%rax
movsd  -0x8(%rsi),%xmm2
movapd %xmm0,%xmm1
mulsd  %xmm2,%xmm1
mulsd  %xmm2,%xmm1
addsd  0x0(%r13,%rax,8),%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
movsd  (%rsi),%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    %r15d,%edi
add    $0x10,%rsi
add    $0x2,%rcx
add    %r15d,%ebx
add    $0xfffffffffffffffe,%r8
cmp    %r8,%r11
jne    18e0 <trstep+0x770>
neg    %r8
mov    0x48(%rsp),%rbx
testb  $0x1,0x8(%rsp)
je     1980 <trstep+0x810>
mov    %r8d,%eax
imul   %ebx,%eax
movsd  (%r10,%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  %xmm0,%xmm0
mov    %r13,%rdi
mov    %ebx,%esi
mov    $0x1,%al
call   1060 <cholmod@plt>
mov    0x40(%rsp),%rbp
mov    %rbp,%rdi
mov    $0x1,%esi
mov    %ebx,%edx
movsd  0x1679(%rip),%xmm0
mov    $0x1,%al
call   1080 <scale@plt>
mov    0x10(%rsp),%rdi
mov    %ebx,%esi
mov    %rbp,%rdx
mov    0x30(%rsp),%rcx
xor    %eax,%eax
call   1050 <linsolve_lower@plt>
mov    %rbp,%rdi
mov    $0x1,%esi
mov    %ebx,%edx
movsd  0x164a(%rip),%xmm0
mov    $0x1,%al
call   1080 <scale@plt>
test   %ebx,%ebx
jle    1b4d <trstep+0x9dd>
movapd 0x60(%rsp),%xmm0
xorpd  0x163d(%rip),%xmm0
cmpq   $0x0,0xb0(%rsp)
je     1db3 <trstep+0xc43>
xor    %r8d,%r8d
mov    $0x1,%ecx
mov    %ebx,%edx
mov    0xa8(%rsp),%rsi
xor    %edi,%edi
xor    %ebp,%ebp
mov    (%rsp),%r9
mov    0x8(%rsp),%r10
mov    0x78(%rsp),%r11
cs nopw 0x0(%rax,%rax,1)
movslq %edx,%rdx
lea    (%rcx,%rdx,1),%rbx
movslq %edi,%rdi
lea    (%rdi,%rbp,1),%rax
movsd  -0x8(%rsi),%xmm1
movapd %xmm1,%xmm2
mulsd  %xmm0,%xmm2
mulsd  %xmm1,%xmm2
addsd  0x0(%r13,%rax,8),%xmm2
movsd  %xmm2,0x0(%r13,%rax,8)
movsd  (%rsi),%xmm1
movapd %xmm1,%xmm2
mulsd  %xmm0,%xmm2
mulsd  %xmm1,%xmm2
addsd  0x0(%r13,%rbx,8),%xmm2
movsd  %xmm2,0x0(%r13,%rbx,8)
add    $0x2,%rbp
add    %r15d,%edi
add    $0x10,%rsi
add    $0x2,%rcx
add    %r15d,%edx
add    $0xfffffffffffffffe,%r8
cmp    %r8,%r11
jne    1a30 <trstep+0x8c0>
neg    %r8
mov    0x48(%rsp),%rbx
test   $0x1,%r10b
je     1acc <trstep+0x95c>
mov    %r8d,%ecx
imul   %ebx,%ecx
movsd  (%r9,%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   %ebx,%ebx
jle    1b4d <trstep+0x9dd>
cmp    $0x4,%ebx
jae    1dce <trstep+0xc5e>
xor    %eax,%eax
mov    0x30(%rsp),%rdx
mov    (%rsp),%rsi
mov    0x8(%rsp),%rdi
jmp    1eb0 <trstep+0xd40>
xchg   %ax,%ax
xorpd  %xmm0,%xmm0
mov    %r13,%rdi
mov    %ebx,%esi
mov    $0x1,%al
call   1060 <cholmod@plt>
mov    0x40(%rsp),%rbp
mov    %rbp,%rdi
mov    $0x1,%esi
mov    %ebx,%edx
movsd  0x1509(%rip),%xmm0
mov    $0x1,%al
call   1080 <scale@plt>
mov    0x10(%rsp),%rdi
mov    %ebx,%esi
mov    %rbp,%rdx
mov    0x30(%rsp),%rcx
xor    %eax,%eax
call   1050 <linsolve_lower@plt>
mov    %rbp,%rdi
mov    $0x1,%esi
mov    %ebx,%edx
movsd  0x14da(%rip),%xmm0
mov    $0x1,%al
call   1080 <scale@plt>
mov    %r14,%rdi
mov    %ebx,%esi
xor    %eax,%eax
call   1040 <l2norm@plt>
movsd  0x20(%rsp),%xmm4
mov    0x10(%rsp),%r11
movsd  (%r14),%xmm0
divsd  (%r11),%xmm0
movsd  %xmm0,(%r12)
cmp    $0x2,%ebx
jl     1ca0 <trstep+0xb30>
mov    $0x1,%r10d
mov    0x28(%rsp),%r8
mov    0xd0(%rsp),%rsi
xor    %r9d,%r9d
jmp    1bd9 <trstep+0xa69>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%r14,%r10,8),%xmm1
subsd  %xmm0,%xmm1
add    %r10,%rcx
divsd  (%r11,%rcx,8),%xmm1
movsd  %xmm1,(%r12,%r10,8)
add    $0x1,%r10
add    $0x1,%r9
add    0xb8(%rsp),%rsi
add    0x28(%rsp),%r8
cmp    0x8(%rsp),%r10
je     1ca0 <trstep+0xb30>
cmp    $0x3,%r9
jae    1bf0 <trstep+0xa80>
xorpd  %xmm0,%xmm0
xor    %ebp,%ebp
jmp    1c4b <trstep+0xadb>
nopw   0x0(%rax,%rax,1)
mov    %r10,%rcx
and    $0xfffffffffffffffc,%rcx
xorpd  %xmm0,%xmm0
xor    %ebp,%ebp
nopl   (%rax)
movsd  (%r12,%rbp,8),%xmm1
movsd  0x8(%r12,%rbp,8),%xmm2
mulsd  -0x18(%rsi,%rbp,8),%xmm1
mulsd  -0x10(%rsi,%rbp,8),%xmm2
addsd  %xmm0,%xmm1
movsd  0x10(%r12,%rbp,8),%xmm3
mulsd  -0x8(%rsi,%rbp,8),%xmm3
addsd  %xmm1,%xmm2
movsd  0x18(%r12,%rbp,8),%xmm0
mulsd  (%rsi,%rbp,8),%xmm0
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm0
add    $0x4,%rbp
cmp    %rbp,%rcx
jne    1c00 <trstep+0xa90>
mov    %r10,%rcx
imul   0x28(%rsp),%rcx
test   $0x3,%r10b
je     1ba0 <trstep+0xa30>
mov    %r10d,%edx
and    $0x3,%edx
lea    (%r8,%rbp,1),%rdi
lea    (%r11,%rdi,8),%rdi
lea    (%r12,%rbp,8),%rbp
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  0x0(%rbp,%rbx,8),%xmm1
mulsd  (%rdi,%rbx,8),%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rbx
cmp    %rbx,%rdx
jne    1c80 <trstep+0xb10>
jmp    1ba0 <trstep+0xa30>
nopl   (%rax)
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0xf0(%rsp)
subsd  %xmm4,%xmm0
movsd  %xmm0,0x38(%rsp)
mov    %r12,%rdi
mov    0x48(%rsp),%rbx
mov    %ebx,%esi
xor    %eax,%eax
call   1040 <l2norm@plt>
movsd  0xf0(%rsp),%xmm7
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movapd %xmm0,%xmm6
xorpd  0x1349(%rip),%xmm6
mulsd  %xmm0,%xmm6
divsd  %xmm7,%xmm6
ucomisd 0xe0(%rsp),%xmm7
setae  %al
movsd  0xe8(%rsp),%xmm0
ucomisd %xmm7,%xmm0
setae  %cl
test   %cl,%al
jne    2055 <trstep+0xee5>
movsd  0x18(%rsp),%xmm0
movapd 0x50(%rsp),%xmm3
subsd  %xmm3,%xmm0
xorpd  %xmm4,%xmm4
ucomisd %xmm4,%xmm0
jae    2055 <trstep+0xee5>
movsd  0x38(%rsp),%xmm5
movapd %xmm5,%xmm2
divsd  %xmm6,%xmm2
movapd 0x60(%rsp),%xmm0
movapd %xmm0,%xmm1
subsd  %xmm2,%xmm1
movapd %xmm3,%xmm2
cmplesd %xmm1,%xmm2
andpd  %xmm2,%xmm1
andnpd %xmm3,%xmm2
orpd   %xmm1,%xmm2
movapd %xmm5,%xmm3
cmpltsd %xmm4,%xmm3
movapd %xmm3,%xmm1
andnpd %xmm2,%xmm1
andpd  %xmm0,%xmm3
orpd   %xmm1,%xmm3
mulsd  %xmm5,%xmm7
mulsd  0x20(%rsp),%xmm6
divsd  %xmm6,%xmm7
subsd  %xmm7,%xmm0
mov    0x10(%rsp),%rdx
mov    (%rsp),%r10
mov    0x78(%rsp),%r11
jmp    1860 <trstep+0x6f0>
xor    %r8d,%r8d
testb  $0x1,0x8(%rsp)
jne    1955 <trstep+0x7e5>
jmp    1980 <trstep+0x810>
xor    %r8d,%r8d
mov    (%rsp),%r9
mov    0x8(%rsp),%r10
test   $0x1,%r10b
jne    1aa4 <trstep+0x934>
jmp    1acc <trstep+0x95c>
cmpq   $0x0,0x98(%rsp)
je     200f <trstep+0xe9f>
mov    0x70(%rsp),%rcx
xor    %eax,%eax
mov    0x30(%rsp),%rdx
mov    (%rsp),%rsi
mov    0x8(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd (%rdx,%rax,8),%xmm0
movupd 0x10(%rdx,%rax,8),%xmm1
movupd (%rsi,%rax,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rsi,%rax,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,(%r14,%rax,8)
movupd %xmm0,0x10(%r14,%rax,8)
movupd 0x20(%rdx,%rax,8),%xmm0
movupd 0x30(%rdx,%rax,8),%xmm1
movupd 0x20(%rsi,%rax,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x30(%rsi,%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    1e00 <trstep+0xc90>
testb  $0x1,0x90(%rsp)
01
je     1e98 <trstep+0xd28>
movupd (%rdx,%rax,8),%xmm0
movupd 0x10(%rdx,%rax,8),%xmm1
movupd (%rsi,%rax,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rsi,%rax,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,(%r14,%rax,8)
movupd %xmm0,0x10(%r14,%rax,8)
mov    0xa0(%rsp),%rcx
mov    %rcx,%rax
cmp    %rdi,%rcx
je     1ec9 <trstep+0xd59>
nopl   0x0(%rax,%rax,1)
movsd  (%rdx,%rax,8),%xmm0
mulsd  (%rsi,%rax,8),%xmm0
movsd  %xmm0,(%r14,%rax,8)
add    $0x1,%rax
cmp    %rax,%rdi
jne    1eb0 <trstep+0xd40>
mov    %r14,%rdi
mov    %ebx,%esi
xor    %eax,%eax
call   1040 <l2norm@plt>
test   %ebx,%ebx
jle    1b59 <trstep+0x9e9>
cmp    $0x4,%ebx
movsd  0x20(%rsp),%xmm4
jae    1efd <trstep+0xd8d>
xor    %ecx,%ecx
mov    0x10(%rsp),%r11
mov    (%rsp),%rsi
mov    0x8(%rsp),%rdi
jmp    1ff0 <trstep+0xe80>
cmpq   $0x0,0x98(%rsp)
je     2032 <trstep+0xec2>
mov    0x70(%rsp),%rdx
xor    %ecx,%ecx
mov    0x10(%rsp),%r11
mov    (%rsp),%rsi
mov    0x8(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd (%rsi,%rcx,8),%xmm0
movupd 0x10(%rsi,%rcx,8),%xmm1
movupd (%r14,%rcx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%r14,%rcx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd 0x20(%r14,%rcx,8),%xmm1
movupd 0x30(%r14,%rcx,8),%xmm3
movupd %xmm2,(%r14,%rcx,8)
movupd %xmm0,0x10(%r14,%rcx,8)
movupd 0x20(%rsi,%rcx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd 0x30(%rsi,%rcx,8),%xmm1
mulpd  %xmm3,%xmm1
movupd %xmm0,0x20(%r14,%rcx,8)
movupd %xmm1,0x30(%r14,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rdx
jne    1f30 <trstep+0xdc0>
testb  $0x1,0x90(%rsp)
01
je     1fce <trstep+0xe5e>
movupd (%rsi,%rcx,8),%xmm0
movupd 0x10(%rsi,%rcx,8),%xmm1
movupd (%r14,%rcx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%r14,%rcx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,(%r14,%rcx,8)
movupd %xmm0,0x10(%r14,%rcx,8)
mov    0xa0(%rsp),%rdx
mov    %rdx,%rcx
cmp    %rdi,%rdx
je     1b64 <trstep+0x9f4>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rsi,%rcx,8),%xmm0
mulsd  (%r14,%rcx,8),%xmm0
movsd  %xmm0,(%r14,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rdi
jne    1ff0 <trstep+0xe80>
jmp    1b64 <trstep+0x9f4>
xor    %eax,%eax
mov    0x30(%rsp),%rdx
mov    (%rsp),%rsi
mov    0x8(%rsp),%rdi
testb  $0x1,0x90(%rsp)
01
jne    1e6d <trstep+0xcfd>
jmp    1e98 <trstep+0xd28>
xor    %ecx,%ecx
mov    0x10(%rsp),%r11
mov    (%rsp),%rsi
mov    0x8(%rsp),%rdi
testb  $0x1,0x90(%rsp)
01
jne    1fa1 <trstep+0xe31>
jmp    1fce <trstep+0xe5e>
movsd  0x20(%rsp),%xmm5
mov    0x80(%rsp),%rax
movapd 0x60(%rsp),%xmm0
movsd  0x38(%rsp),%xmm3
jmp    218b <trstep+0x101b>
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    20bc <trstep+0xf4c>
xor    %edi,%edi
jmp    212d <trstep+0xfbd>
xor    %esi,%esi
test   $0x1,%dl
jne    172b <trstep+0x5bb>
jmp    1740 <trstep+0x5d0>
xor    %edx,%edx
test   $0x1,%sil
jne    14ca <trstep+0x35a>
jmp    14fe <trstep+0x38e>
movabs $0x7ffffffffffffffe,%rdi
ff ff 7f
add    $0xfffffffffffffffe,%rdi
and    %rdi,%rsi
xor    %edi,%edi
nop
movups 0x0(%rbp,%rdi,8),%xmm0
movups 0x10(%rbp,%rdi,8),%xmm1
movups %xmm0,(%rbx,%rdi,8)
movups %xmm1,0x10(%rbx,%rdi,8)
movups 0x20(%rbp,%rdi,8),%xmm0
movups 0x30(%rbp,%rdi,8),%xmm1
movups %xmm0,0x20(%rbx,%rdi,8)
movups %xmm1,0x30(%rbx,%rdi,8)
movups 0x40(%rbp,%rdi,8),%xmm0
movups 0x50(%rbp,%rdi,8),%xmm1
movups %xmm0,0x40(%rbx,%rdi,8)
movups %xmm1,0x50(%rbx,%rdi,8)
movupd 0x60(%rbp,%rdi,8),%xmm0
movupd 0x70(%rbp,%rdi,8),%xmm1
movupd %xmm0,0x60(%rbx,%rdi,8)
movupd %xmm1,0x70(%rbx,%rdi,8)
add    $0x10,%rdi
add    $0xfffffffffffffffc,%rsi
jne    20d0 <trstep+0xf60>
test   %rdx,%rdx
je     216f <trstep+0xfff>
lea    (%rbx,%rdi,8),%rsi
add    $0x10,%rsi
mov    0x18(%rsp),%rbp
lea    0x10(,%rdi,8),%rdi
add    %rbp,%rdi
shl    $0x5,%rdx
xor    %ebp,%ebp
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    2150 <trstep+0xfe0>
cmp    %r8,%rcx
mov    0x18(%rsp),%rbp
jne    1381 <trstep+0x211>
xorpd  %xmm0,%xmm0
ucomisd %xmm5,%xmm2
ja     218b <trstep+0x101b>
movapd %xmm2,%xmm5
movsd  %xmm5,(%rax)
movsd  %xmm0,0x8(%rax)
movsd  0x88(%rsp),%xmm0
movsd  %xmm0,0x10(%rax)
movsd  %xmm3,0x18(%rax)
movsd  %xmm6,0x20(%rax)
movaps 0xc0(%rsp),%xmm0
movsd  %xmm0,0x28(%rax)
mov    %r14,%rdi
call   1030 <free@plt>
mov    %r12,%rdi
add    $0xf8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

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