int cauchy_(int n, double *x, double *l, double *u, int *nbd, double *g,
            int *iorder, int *iwhere, double *t, double *d, double *xcp, int m,
            double *wy, double *ws, double *sy, double *wt, double theta,
            int col, int head, double *p, double *c, double *wbp, double *v,
            int *nint, double *sg, double *yg, double *sbgnrm, int *info,
            double epsmch) {
  static double tu, tl;
  int wy_offset, ws_offset, sy_offset, wt_offset, i1, i2;
  double d1, f1, f2, dt, tj, tj0;
  double dibp, dtm, wmc, wmp, wmw;
  int ibp, col2;
  int iter, bnded, nfree;
  double zibp, tsum, dibp2;
  double neggi, bkmin;
  double f2_orig;
  int nleft, nbreak, ibkmin;
  int pointr, xlower, xupper;
  int i, j;
  --xcp;
  --d;
  --t;
  --iwhere;
  --iorder;
  --g;
  --nbd;
  --u;
  --l;
  --x;
  --yg;
  --sg;
  --v;
  --wbp;
  --c;
  --p;
  wt_offset = 1 + m;
  wt -= wt_offset;
  sy_offset = 1 + m;
  sy -= sy_offset;
  ws_offset = 1 + n;
  ws -= ws_offset;
  wy_offset = 1 + n;
  wy -= wy_offset;
  if (*sbgnrm <= 0.) {
    dcopy_(n, &x[1], &xcp[1]);
    return 0;
  }
  bnded = 1;
  nfree = n + 1;
  nbreak = 0;
  ibkmin = 0;
  bkmin = 0.;
  col2 = col * 2;
  f1 = 0.;
  for (i = 1; i <= col2; ++i) {
    p[i] = 0.;
  }
  for (i = 1; i <= n; ++i) {
    neggi = -g[i];
    if (iwhere[i] != 3 && iwhere[i] != -1) {
      if (nbd[i] <= 2) {
        tl = x[i] - l[i];
      }
      if (nbd[i] >= 2) {
        tu = u[i] - x[i];
      }
      xlower = nbd[i] <= 2 && tl <= 0.0;
      xupper = nbd[i] >= 2 && tu <= 0.0;
      iwhere[i] = 0;
      if (xlower) {
        if (neggi <= 0.) {
          iwhere[i] = 1;
        }
      } else if (xupper) {
        if (neggi >= 0.) {
          iwhere[i] = 2;
        }
      } else {
        if (fabs(neggi) <= 0) {
          iwhere[i] = -3;
        }
      }
    }
    pointr = head;
    if (iwhere[i] != 0 && iwhere[i] != -1) {
      d[i] = 0.;
    } else {
      d[i] = neggi;
      f1 -= neggi * neggi;
      i2 = col;
      for (j = 1; j <= i2; ++j) {
        p[j] += wy[i + pointr * n] * neggi;
        p[col + j] += ws[i + pointr * n] * neggi;
        pointr = pointr % m + 1;
      }
      if (nbd[i] <= 2 && nbd[i] != 0 && neggi < 0) {
        ++nbreak;
        iorder[nbreak] = i;
        t[nbreak] = tl / (-neggi);
        if (nbreak == 1 || t[nbreak] < bkmin) {
          bkmin = t[nbreak];
          ibkmin = nbreak;
        }
      } else if (nbd[i] >= 2 && neggi > 0) {
        ++nbreak;
        iorder[nbreak] = i;
        t[nbreak] = tu / neggi;
        if (nbreak == 1 || t[nbreak] < bkmin) {
          bkmin = t[nbreak];
          ibkmin = nbreak;
        }
      } else {
        --nfree;
        iorder[nfree] = i;
        if (fabs(neggi) > 0) {
          bnded = 0;
        }
      }
    }
  }
  if (theta != 1.0) {
    dscal_(col, theta, &p[col + 1]);
  }
  dcopy_(n, &x[1], &xcp[1]);
  if (nbreak == 0 && nfree == n + 1) {
    return 0;
  }
  for (j = 1; j <= col2; ++j) {
    c[j] = 0.0;
  }
  f2 = -theta * f1;
  f2_orig = f2;
  if (col > 0) {
    bmv_(m, &sy[sy_offset], &wt[wt_offset], col, &p[1], &v[1], info);
    if (*info != 0) {
      return 0;
    }
    f2 -= ddot_(col2, &v[1], &p[1]);
  }
  dtm = -f1 / f2;
  tsum = 0.;
  *nint = 1;
  if (nbreak == 0) {
    goto L888;
  }
  nleft = nbreak;
  iter = 1;
  tj = 0.;
L777:
  tj0 = tj;
  if (iter == 1) {
    tj = bkmin;
    ibp = iorder[ibkmin];
  } else {
    if (iter == 2) {
      if (ibkmin != nbreak) {
        t[ibkmin] = t[nbreak];
        iorder[ibkmin] = iorder[nbreak];
      }
    }
    i1 = iter - 2;
    hpsolb_(nleft, &t[1], &iorder[1], i1);
    tj = t[nleft];
    ibp = iorder[nleft];
  }
  dt = tj - tj0;
  if (dtm < dt) {
    goto L888;
  }
  tsum += dt;
  --nleft;
  ++iter;
  dibp = d[ibp];
  d[ibp] = 0.;
  if (dibp > 0.) {
    zibp = u[ibp] - x[ibp];
    xcp[ibp] = u[ibp];
    iwhere[ibp] = 2;
  } else {
    zibp = l[ibp] - x[ibp];
    xcp[ibp] = l[ibp];
    iwhere[ibp] = 1;
  }
  if (nleft == 0 && nbreak == n) {
    dtm = dt;
    goto L999;
  }
  ++(*nint);
  d1 = dibp;
  dibp2 = d1 * d1;
  f1 = f1 + dt * f2 + dibp2 - theta * dibp * zibp;
  f2 -= theta * dibp2;
  if (col > 0) {
    daxpy_(col2, dt, &p[1], &c[1]);
    pointr = head;
    for (j = 1; j <= col; ++j) {
      wbp[j] = wy[ibp + pointr * n];
      wbp[col + j] = theta * ws[ibp + pointr * n];
      pointr = pointr % m + 1;
    }
    bmv_(m, &sy[sy_offset], &wt[wt_offset], col, &wbp[1], &v[1], info);
    if (*info != 0) {
      return 0;
    }
    wmc = ddot_(col2, &c[1], &v[1]);
    wmp = ddot_(col2, &p[1], &v[1]);
    wmw = ddot_(col2, &wbp[1], &v[1]);
    d1 = -dibp;
    daxpy_(col2, d1, &wbp[1], &p[1]);
    f1 += dibp * wmc;
    f2 = f2 + dibp * 2. * wmp - dibp2 * wmw;
  }
  d1 = epsmch * f2_orig;
  f2 = ((d1) >= (f2) ? (d1) : (f2));
  if (nleft > 0) {
    dtm = -f1 / f2;
    goto L777;
  } else if (bnded) {
    f1 = 0.;
    f2 = 0.;
    dtm = 0.;
  } else {
    dtm = -f1 / f2;
  }
L888:
  if (dtm <= 0) {
    dtm = 0;
  }
  tsum += dtm;
  daxpy_(n, tsum, &d[1], &xcp[1]);
L999:
  if (col > 0) {
    daxpy_(col2, dtm, &p[1], &c[1]);
  }
  return 0;
}


x86 assembly (clang, -O0):
<cauchy_>:
push   %rbp
mov    %rsp,%rbp
sub    $0x130,%rsp
mov    0xb0(%rbp),%rax
mov    0xa8(%rbp),%rax
mov    0xa0(%rbp),%rax
mov    0x98(%rbp),%rax
mov    0x90(%rbp),%rax
mov    0x88(%rbp),%rax
mov    0x80(%rbp),%rax
mov    0x78(%rbp),%rax
mov    0x70(%rbp),%rax
mov    0x68(%rbp),%eax
mov    0x60(%rbp),%eax
mov    0x58(%rbp),%rax
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%eax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movsd  %xmm0,-0x38(%rbp)
movsd  %xmm1,-0x40(%rbp)
mov    0x30(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x30(%rbp)
mov    0x28(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x28(%rbp)
mov    0x20(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x20(%rbp)
mov    0x18(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,0x18(%rbp)
mov    0x10(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,0x10(%rbp)
mov    -0x30(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x10(%rbp)
mov    0xa0(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0xa0(%rbp)
mov    0x98(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x98(%rbp)
mov    0x88(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x88(%rbp)
mov    0x80(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x80(%rbp)
mov    0x78(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x78(%rbp)
mov    0x70(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x70(%rbp)
mov    0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%ecx
mov    0x58(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,0x58(%rbp)
mov    0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%ecx
mov    0x50(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,0x50(%rbp)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%ecx
mov    0x48(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,0x48(%rbp)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%ecx
mov    0x40(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,0x40(%rbp)
mov    0xa8(%rbp),%rax
xorps  %xmm0,%xmm0
ucomisd (%rax),%xmm0
jb     1390 <cauchy_+0x230>
mov    -0x8(%rbp),%edi
mov    -0x10(%rbp),%rsi
add    $0x8,%rsi
mov    0x30(%rbp),%rdx
add    $0x8,%rdx
mov    $0x0,%al
call   1030 <dcopy_@plt>
movl   $0x0,-0x4(%rbp)
jmp    2339 <cauchy_+0x11d9>
movl   $0x1,-0xc0(%rbp)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
movl   $0x0,-0x100(%rbp)
movl   $0x0,-0x104(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
mov    0x60(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0xb8(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x1,-0x114(%rbp)
mov    -0x114(%rbp),%eax
cmp    -0xb8(%rbp),%eax
jg     141c <cauchy_+0x2bc>
mov    0x70(%rbp),%rax
movslq -0x114(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x114(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x114(%rbp)
jmp    13e3 <cauchy_+0x283>
movl   $0x1,-0x114(%rbp)
mov    -0x114(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     19e5 <cauchy_+0x885>
mov    -0x30(%rbp),%rax
movslq -0x114(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
mov    0x18(%rbp),%rax
movslq -0x114(%rbp),%rcx
cmpl   $0x3,(%rax,%rcx,4)
je     164d <cauchy_+0x4ed>
mov    0x18(%rbp),%rax
movslq -0x114(%rbp),%rcx
cmpl   $0xffffffff,(%rax,%rcx,4)
je     164d <cauchy_+0x4ed>
mov    -0x28(%rbp),%rax
movslq -0x114(%rbp),%rcx
cmpl   $0x2,(%rax,%rcx,4)
jg     14cb <cauchy_+0x36b>
mov    -0x10(%rbp),%rax
movslq -0x114(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x114(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x3b95(%rip)
mov    -0x28(%rbp),%rax
movslq -0x114(%rbp),%rcx
cmpl   $0x2,(%rax,%rcx,4)
jl     1508 <cauchy_+0x3a8>
mov    -0x20(%rbp),%rax
movslq -0x114(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x114(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x3b50(%rip)
mov    -0x28(%rbp),%rcx
movslq -0x114(%rbp),%rdx
xor    %eax,%eax
cmpl   $0x2,(%rcx,%rdx,4)
mov    %al,-0x119(%rbp)
jg     1539 <cauchy_+0x3d9>
xorps  %xmm0,%xmm0
ucomisd 0x3b30(%rip),%xmm0
setae  %al
mov    %al,-0x119(%rbp)
mov    -0x119(%rbp),%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x10c(%rbp)
mov    -0x28(%rbp),%rcx
movslq -0x114(%rbp),%rdx
xor    %eax,%eax
cmpl   $0x2,(%rcx,%rdx,4)
mov    %al,-0x11a(%rbp)
jl     157b <cauchy_+0x41b>
xorps  %xmm0,%xmm0
ucomisd 0x3ae6(%rip),%xmm0
setae  %al
mov    %al,-0x11a(%rbp)
mov    -0x11a(%rbp),%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x110(%rbp)
mov    0x18(%rbp),%rax
movslq -0x114(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
cmpl   $0x0,-0x10c(%rbp)
je     15d3 <cauchy_+0x473>
xorps  %xmm0,%xmm0
ucomisd -0xe8(%rbp),%xmm0
ff
jb     15ce <cauchy_+0x46e>
mov    0x18(%rbp),%rax
movslq -0x114(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
jmp    1648 <cauchy_+0x4e8>
cmpl   $0x0,-0x110(%rbp)
je     160c <cauchy_+0x4ac>
movsd  -0xe8(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1607 <cauchy_+0x4a7>
mov    0x18(%rbp),%rax
movslq -0x114(%rbp),%rcx
movl   $0x2,(%rax,%rcx,4)
jmp    1643 <cauchy_+0x4e3>
movsd  -0xe8(%rbp),%xmm1
ff
movaps 0x19f5(%rip),%xmm0
pand   %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jb     163e <cauchy_+0x4de>
mov    0x18(%rbp),%rax
movslq -0x114(%rbp),%rcx
movl   $0xfffffffd,(%rax,%rcx,4)
jmp    1643 <cauchy_+0x4e3>
jmp    1648 <cauchy_+0x4e8>
jmp    164d <cauchy_+0x4ed>
mov    0x68(%rbp),%eax
mov    %eax,-0x108(%rbp)
mov    0x18(%rbp),%rax
movslq -0x114(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     1698 <cauchy_+0x538>
mov    0x18(%rbp),%rax
movslq -0x114(%rbp),%rcx
cmpl   $0xffffffff,(%rax,%rcx,4)
je     1698 <cauchy_+0x538>
mov    0x28(%rbp),%rax
movslq -0x114(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    19cc <cauchy_+0x86c>
movsd  -0xe8(%rbp),%xmm0
ff
mov    0x28(%rbp),%rax
movslq -0x114(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xe8(%rbp),%xmm0
ff
movsd  -0xe8(%rbp),%xmm2
ff
movsd  -0x68(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    0x60(%rbp),%eax
mov    %eax,-0x58(%rbp)
movl   $0x1,-0x118(%rbp)
mov    -0x118(%rbp),%eax
cmp    -0x58(%rbp),%eax
jg     17ba <cauchy_+0x65a>
mov    0x40(%rbp),%rax
mov    -0x114(%rbp),%ecx
mov    -0x108(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0xe8(%rbp),%xmm2
ff
mov    0x70(%rbp),%rax
movslq -0x118(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x48(%rbp),%rax
mov    -0x114(%rbp),%ecx
mov    -0x108(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0xe8(%rbp),%xmm2
ff
mov    0x70(%rbp),%rax
mov    0x60(%rbp),%ecx
add    -0x118(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x108(%rbp),%eax
cltd
idivl  0x38(%rbp)
add    $0x1,%edx
mov    %edx,-0x108(%rbp)
mov    -0x118(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x118(%rbp)
jmp    16f9 <cauchy_+0x599>
mov    -0x28(%rbp),%rax
movslq -0x114(%rbp),%rcx
cmpl   $0x2,(%rax,%rcx,4)
jg     18ab <cauchy_+0x74b>
mov    -0x28(%rbp),%rax
movslq -0x114(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     18ab <cauchy_+0x74b>
xorps  %xmm0,%xmm0
ucomisd -0xe8(%rbp),%xmm0
ff
jbe    18ab <cauchy_+0x74b>
mov    -0x100(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x100(%rbp)
mov    -0x114(%rbp),%edx
mov    0x10(%rbp),%rax
movslq -0x100(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
movsd  0x3840(%rip),%xmm0
movsd  -0xe8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
divsd  %xmm1,%xmm0
mov    0x20(%rbp),%rax
movslq -0x100(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x1,-0x100(%rbp)
je     1882 <cauchy_+0x722>
mov    0x20(%rbp),%rax
movslq -0x100(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0xf0(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    18a6 <cauchy_+0x746>
mov    0x20(%rbp),%rax
movslq -0x100(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0x100(%rbp),%eax
mov    %eax,-0x104(%rbp)
jmp    19c7 <cauchy_+0x867>
mov    -0x28(%rbp),%rax
movslq -0x114(%rbp),%rcx
cmpl   $0x2,(%rax,%rcx,4)
jl     1970 <cauchy_+0x810>
movsd  -0xe8(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1970 <cauchy_+0x810>
mov    -0x100(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x100(%rbp)
mov    -0x114(%rbp),%edx
mov    0x10(%rbp),%rax
movslq -0x100(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
movsd  0x3758(%rip),%xmm0
divsd  -0xe8(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
movslq -0x100(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x1,-0x100(%rbp)
je     1947 <cauchy_+0x7e7>
mov    0x20(%rbp),%rax
movslq -0x100(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0xf0(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    196b <cauchy_+0x80b>
mov    0x20(%rbp),%rax
movslq -0x100(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0x100(%rbp),%eax
mov    %eax,-0x104(%rbp)
jmp    19c2 <cauchy_+0x862>
mov    -0xc4(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xc4(%rbp)
mov    -0x114(%rbp),%edx
mov    0x10(%rbp),%rax
movslq -0xc4(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
movsd  -0xe8(%rbp),%xmm0
ff
movaps 0x166e(%rip),%xmm1
pand   %xmm1,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    19bd <cauchy_+0x85d>
movl   $0x0,-0xc0(%rbp)
jmp    19c2 <cauchy_+0x862>
jmp    19c7 <cauchy_+0x867>
jmp    19cc <cauchy_+0x86c>
jmp    19d1 <cauchy_+0x871>
mov    -0x114(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x114(%rbp)
jmp    1426 <cauchy_+0x2c6>
movsd  -0x38(%rbp),%xmm0
movsd  0x160e(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    1a07 <cauchy_+0x8a7>
jp     1a07 <cauchy_+0x8a7>
jmp    1a29 <cauchy_+0x8c9>
mov    0x60(%rbp),%edi
movsd  -0x38(%rbp),%xmm0
mov    0x70(%rbp),%rsi
mov    0x60(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x3,%rax
add    %rax,%rsi
mov    $0x1,%al
call   1050 <dscal_@plt>
mov    -0x8(%rbp),%edi
mov    -0x10(%rbp),%rsi
add    $0x8,%rsi
mov    0x30(%rbp),%rdx
add    $0x8,%rdx
mov    $0x0,%al
call   1030 <dcopy_@plt>
cmpl   $0x0,-0x100(%rbp)
jne    1a70 <cauchy_+0x910>
mov    -0xc4(%rbp),%eax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jne    1a70 <cauchy_+0x910>
movl   $0x0,-0x4(%rbp)
jmp    2339 <cauchy_+0x11d9>
movl   $0x1,-0x118(%rbp)
mov    -0x118(%rbp),%eax
cmp    -0xb8(%rbp),%eax
jg     1ab3 <cauchy_+0x953>
mov    0x78(%rbp),%rax
movslq -0x118(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x118(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x118(%rbp)
jmp    1a7a <cauchy_+0x91a>
movsd  -0x38(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
cmpl   $0x0,0x60(%rbp)
jle    1b87 <cauchy_+0xa27>
mov    0x38(%rbp),%edi
mov    0x50(%rbp),%rsi
movslq -0x4c(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rsi
mov    0x58(%rbp),%rdx
movslq -0x50(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rdx
mov    0x60(%rbp),%ecx
mov    0x70(%rbp),%r8
add    $0x8,%r8
mov    0x88(%rbp),%r9
add    $0x8,%r9
mov    0xb0(%rbp),%rax
mov    %rax,(%rsp)
mov    $0x0,%al
call   1070 <bmv_@plt>
mov    0xb0(%rbp),%rax
cmpl   $0x0,(%rax)
je     1b55 <cauchy_+0x9f5>
movl   $0x0,-0x4(%rbp)
jmp    2339 <cauchy_+0x11d9>
mov    -0xb8(%rbp),%edi
mov    0x88(%rbp),%rsi
add    $0x8,%rsi
mov    0x70(%rbp),%rdx
add    $0x8,%rdx
mov    $0x0,%al
call   1040 <ddot_@plt>
cvtsi2sd %eax,%xmm1
movsd  -0x70(%rbp),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x68(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
divsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    0x90(%rbp),%rax
movl   $0x1,(%rax)
cmpl   $0x0,-0x100(%rbp)
jne    1bda <cauchy_+0xa7a>
jmp    22ad <cauchy_+0x114d>
mov    -0x100(%rbp),%eax
mov    %eax,-0xfc(%rbp)
movl   $0x1,-0xbc(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
cmpl   $0x1,-0xbc(%rbp)
jne    1c38 <cauchy_+0xad8>
movsd  -0xf0(%rbp),%xmm0
ff
movsd  %xmm0,-0x80(%rbp)
mov    0x10(%rbp),%rax
movslq -0x104(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xb4(%rbp)
jmp    1ced <cauchy_+0xb8d>
cmpl   $0x2,-0xbc(%rbp)
jne    1c98 <cauchy_+0xb38>
mov    -0x104(%rbp),%eax
cmp    -0x100(%rbp),%eax
je     1c93 <cauchy_+0xb33>
mov    0x20(%rbp),%rax
movslq -0x100(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
movslq -0x104(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x10(%rbp),%rax
movslq -0x100(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    0x10(%rbp),%rax
movslq -0x104(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1c98 <cauchy_+0xb38>
mov    -0xbc(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x54(%rbp)
mov    -0xfc(%rbp),%edi
mov    0x20(%rbp),%rsi
add    $0x8,%rsi
mov    0x10(%rbp),%rdx
add    $0x4,%rdx
mov    -0x54(%rbp),%ecx
mov    $0x0,%al
call   1060 <hpsolb_@plt>
mov    0x20(%rbp),%rax
movslq -0xfc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    0x10(%rbp),%rax
movslq -0xfc(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xb4(%rbp)
movsd  -0x80(%rbp),%xmm0
subsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
movsd  -0x98(%rbp),%xmm1
ff
movsd  -0x78(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1d1b <cauchy_+0xbbb>
jmp    22ad <cauchy_+0x114d>
movsd  -0x78(%rbp),%xmm0
addsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0xfc(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xfc(%rbp)
mov    -0xbc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xbc(%rbp)
mov    0x28(%rbp),%rax
movslq -0xb4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    0x28(%rbp),%rax
movslq -0xb4(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x90(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1ded <cauchy_+0xc8d>
mov    -0x20(%rbp),%rax
movslq -0xb4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0xb4(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x20(%rbp),%rax
movslq -0xb4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0xb4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
movslq -0xb4(%rbp),%rcx
movl   $0x2,(%rax,%rcx,4)
jmp    1e47 <cauchy_+0xce7>
mov    -0x18(%rbp),%rax
movslq -0xb4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0xb4(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x18(%rbp),%rax
movslq -0xb4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0xb4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
movslq -0xb4(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
cmpl   $0x0,-0xfc(%rbp)
jne    1e75 <cauchy_+0xd15>
mov    -0x100(%rbp),%eax
cmp    -0x8(%rbp),%eax
jne    1e75 <cauchy_+0xd15>
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
jmp    2303 <cauchy_+0x11a3>
mov    0x90(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
movsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
addsd  -0xe0(%rbp),%xmm1
ff
movsd  -0x38(%rbp),%xmm0
mulsd  -0x90(%rbp),%xmm0
ff
movsd  -0xd0(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x38(%rbp),%xmm0
movsd  -0xe0(%rbp),%xmm2
ff
movsd  -0x70(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
cmpl   $0x0,0x60(%rbp)
jle    21c4 <cauchy_+0x1064>
mov    -0xb8(%rbp),%edi
movsd  -0x78(%rbp),%xmm0
mov    0x70(%rbp),%rsi
add    $0x8,%rsi
mov    0x78(%rbp),%rdx
add    $0x8,%rdx
mov    $0x1,%al
call   1080 <daxpy_@plt>
mov    0x68(%rbp),%eax
mov    %eax,-0x108(%rbp)
movl   $0x1,-0x118(%rbp)
mov    -0x118(%rbp),%eax
cmp    0x60(%rbp),%eax
jg     2011 <cauchy_+0xeb1>
mov    0x40(%rbp),%rax
mov    -0xb4(%rbp),%ecx
mov    -0x108(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x80(%rbp),%rax
movslq -0x118(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x38(%rbp),%xmm0
mov    0x48(%rbp),%rax
mov    -0xb4(%rbp),%ecx
mov    -0x108(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x80(%rbp),%rax
mov    0x60(%rbp),%ecx
add    -0x118(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x108(%rbp),%eax
cltd
idivl  0x38(%rbp)
add    $0x1,%edx
mov    %edx,-0x108(%rbp)
mov    -0x118(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x118(%rbp)
jmp    1f6f <cauchy_+0xe0f>
mov    0x38(%rbp),%edi
mov    0x50(%rbp),%rsi
movslq -0x4c(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rsi
mov    0x58(%rbp),%rdx
movslq -0x50(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rdx
mov    0x60(%rbp),%ecx
mov    0x80(%rbp),%r8
add    $0x8,%r8
mov    0x88(%rbp),%r9
add    $0x8,%r9
mov    0xb0(%rbp),%rax
mov    %rax,(%rsp)
mov    $0x0,%al
call   1070 <bmv_@plt>
mov    0xb0(%rbp),%rax
cmpl   $0x0,(%rax)
je     2079 <cauchy_+0xf19>
movl   $0x0,-0x4(%rbp)
jmp    2339 <cauchy_+0x11d9>
mov    -0xb8(%rbp),%edi
mov    0x78(%rbp),%rsi
add    $0x8,%rsi
mov    0x88(%rbp),%rdx
add    $0x8,%rdx
mov    $0x0,%al
call   1040 <ddot_@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0xb8(%rbp),%edi
mov    0x70(%rbp),%rsi
add    $0x8,%rsi
mov    0x88(%rbp),%rdx
add    $0x8,%rdx
mov    $0x0,%al
call   1040 <ddot_@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0xb8(%rbp),%edi
mov    0x80(%rbp),%rsi
add    $0x8,%rsi
mov    0x88(%rbp),%rdx
add    $0x8,%rdx
mov    $0x0,%al
call   1040 <ddot_@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0xb8(%rbp),%edi
movsd  -0x60(%rbp),%xmm0
mov    0x80(%rbp),%rsi
add    $0x8,%rsi
mov    0x70(%rbp),%rdx
add    $0x8,%rdx
mov    $0x1,%al
call   1080 <daxpy_@plt>
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x70(%rbp),%xmm0
movsd  0xe90(%rip),%xmm1
mulsd  -0x90(%rbp),%xmm1
ff
movsd  -0xa8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xe0(%rbp),%xmm0
ff
movsd  -0xb0(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x40(%rbp),%xmm0
mulsd  -0xf8(%rbp),%xmm0
ff
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
ucomisd -0x70(%rbp),%xmm0
jb     21f8 <cauchy_+0x1098>
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
jmp    2205 <cauchy_+0x10a5>
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x128(%rbp),%xmm0
ff
movsd  %xmm0,-0x70(%rbp)
cmpl   $0x0,-0xfc(%rbp)
jle    224d <cauchy_+0x10ed>
movsd  -0x68(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
divsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
jmp    1bf8 <cauchy_+0xa98>
cmpl   $0x0,-0xc0(%rbp)
je     227a <cauchy_+0x111a>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
jmp    22a3 <cauchy_+0x1143>
movsd  -0x68(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
divsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
jmp    22a8 <cauchy_+0x1148>
jmp    22ad <cauchy_+0x114d>
xorps  %xmm0,%xmm0
ucomisd -0x98(%rbp),%xmm0
ff
jb     22c9 <cauchy_+0x1169>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
addsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x8(%rbp),%edi
movsd  -0xd8(%rbp),%xmm0
ff
mov    0x28(%rbp),%rsi
add    $0x8,%rsi
mov    0x30(%rbp),%rdx
add    $0x8,%rdx
mov    $0x1,%al
call   1080 <daxpy_@plt>
cmpl   $0x0,0x60(%rbp)
jle    2332 <cauchy_+0x11d2>
mov    -0xb8(%rbp),%edi
movsd  -0x98(%rbp),%xmm0
ff
mov    0x70(%rbp),%rsi
add    $0x8,%rsi
mov    0x78(%rbp),%rdx
add    $0x8,%rdx
mov    $0x1,%al
call   1080 <daxpy_@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x130,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<cauchy_>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x168,%rsp
movsd  %xmm1,0x60(%rsp)
mov    %r8,0x40(%rsp)
mov    %rdx,0xb8(%rsp)
mov    %edi,%r14d
mov    0x1c0(%rsp),%rdx
mov    0x238(%rsp),%rax
xorpd  %xmm1,%xmm1
ucomisd (%rax),%xmm1
jae    153b <cauchy_+0x3cb>
mov    %r9,%r12
mov    %rcx,%rbp
mov    %rsi,0x38(%rsp)
mov    0x200(%rsp),%rdi
mov    0x1f0(%rsp),%esi
mov    %r14d,%eax
not    %eax
movslq %eax,%r13
shl    $0x3,%r13
lea    (%rsi,%rsi,1),%ebx
test   %esi,%esi
movapd %xmm0,0x80(%rsp)
mov    %rcx,0x58(%rsp)
jle    121e <cauchy_+0xae>
cmp    $0x2,%ebx
mov    $0x1,%edx
cmovge %ebx,%edx
shl    $0x3,%rdx
xor    %esi,%esi
call   1050 <memset@plt>
movapd 0x80(%rsp),%xmm0
mov    0x200(%rsp),%rdi
mov    0x1f0(%rsp),%esi
mov    %ebx,0x14(%rsp)
mov    0x1a8(%rsp),%rbx
lea    0x1(%r14),%ecx
mov    0x1d8(%rsp),%r15
add    %r13,%r15
add    0x1d0(%rsp),%r13
movslq %esi,%rax
test   %r14d,%r14d
mov    %rax,0xa0(%rsp)
mov    %ecx,0x70(%rsp)
jle    154a <cauchy_+0x3da>
movsd  0x2dff(%rip),%xmm1
movsd  0x2dff(%rip),%xmm7
lea    0x1(%rsi),%r10d
mov    %ecx,%r8d
lea    (%rdi,%rax,8),%r11
add    $0xffffffffffffffff,%r10
movl   $0x1,0x34(%rsp)
xorpd  %xmm9,%xmm9
xor    %eax,%eax
mov    %rax,0x28(%rsp)
mov    $0x1,%ebp
movapd 0xd66(%rip),%xmm8
xor    %eax,%eax
mov    %rax,0x18(%rsp)
xorpd  %xmm2,%xmm2
mov    %ecx,0x20(%rsp)
xorpd  %xmm3,%xmm3
mov    0x40(%rsp),%rcx
jmp    12ec <cauchy_+0x17c>
mov    $0xfffffffd,%eax
ucomisd %xmm9,%xmm4
jne    13a0 <cauchy_+0x230>
jp     13a0 <cauchy_+0x230>
mov    %eax,-0x4(%rbx,%rbp,4)
mov    0x1b8(%rsp),%rax
movq   $0x0,-0x8(%rax,%rbp,8)
add    $0x1,%rbp
cmp    %r8,%rbp
je     156c <cauchy_+0x3fc>
movsd  -0x8(%r12,%rbp,8),%xmm4
mov    -0x4(%rbx,%rbp,4),%eax
cmp    $0xffffffff,%eax
je     13a0 <cauchy_+0x230>
cmp    $0x3,%eax
je     12ce <cauchy_+0x15e>
mov    -0x4(%rcx,%rbp,4),%eax
mov    0x38(%rsp),%rdx
movsd  -0x8(%rdx,%rbp,8),%xmm5
cmp    $0x2,%eax
jg     1335 <cauchy_+0x1c5>
movapd %xmm5,%xmm7
mov    0xb8(%rsp),%rdx
subsd  -0x8(%rdx,%rbp,8),%xmm7
movsd  %xmm7,0x2d35(%rip)
jne    1350 <cauchy_+0x1e0>
mov    0x58(%rsp),%rdx
movsd  -0x8(%rdx,%rbp,8),%xmm1
subsd  %xmm5,%xmm1
movsd  %xmm1,0x2d14(%rip)
mov    $0x1,%dl
jmp    1352 <cauchy_+0x1e2>
xor    %edx,%edx
movl   $0x0,-0x4(%rbx,%rbp,4)
cmp    $0x2,%eax
jg     1378 <cauchy_+0x208>
ucomisd %xmm7,%xmm9
jb     1378 <cauchy_+0x208>
mov    $0x1,%eax
ucomisd %xmm9,%xmm4
jae    12ca <cauchy_+0x15a>
jmp    13a0 <cauchy_+0x230>
ucomisd %xmm1,%xmm9
setae  %al
and    %al,%dl
cmp    $0x1,%dl
jne    12b4 <cauchy_+0x144>
mov    $0x2,%eax
ucomisd %xmm4,%xmm9
jae    12ca <cauchy_+0x15a>
nopl   0x0(%rax,%rax,1)
movapd %xmm4,%xmm5
xorpd  %xmm8,%xmm5
mov    0x1b8(%rsp),%rax
movsd  %xmm5,-0x8(%rax,%rbp,8)
test   %esi,%esi
mov    0x1c8(%rsp),%r9d
jle    1417 <cauchy_+0x2a7>
xor    %ebx,%ebx
mov    0x1f8(%rsp),%edx
nopl   0x0(%rax)
mov    %edx,%eax
imul   %r14d,%eax
add    %ebp,%eax
cltq
movsd  0x0(%r13,%rax,8),%xmm6
mulsd  %xmm5,%xmm6
addsd  (%rdi,%rbx,8),%xmm6
movsd  %xmm6,(%rdi,%rbx,8)
movsd  (%r15,%rax,8),%xmm6
mulsd  %xmm5,%xmm6
addsd  (%r11,%rbx,8),%xmm6
movsd  %xmm6,(%r11,%rbx,8)
mov    %edx,%eax
cltd
idiv   %r9d
add    $0x1,%edx
add    $0x1,%rbx
cmp    %rbx,%r10
jne    13d0 <cauchy_+0x260>
movapd %xmm4,%xmm6
mulsd  %xmm5,%xmm6
addsd  %xmm6,%xmm3
mov    -0x4(%rcx,%rbp,4),%eax
cmp    $0x2,%eax
jg     14a0 <cauchy_+0x330>
test   %eax,%eax
je     14a0 <cauchy_+0x330>
ucomisd %xmm9,%xmm4
jbe    14a0 <cauchy_+0x330>
mov    0x18(%rsp),%rcx
lea    0x1(%rcx),%eax
movslq %ecx,%rdx
mov    0x1a0(%rsp),%rbx
mov    %ebp,(%rbx,%rdx,4)
movapd %xmm7,%xmm5
divsd  %xmm4,%xmm5
mov    0x1b0(%rsp),%rbx
movsd  %xmm5,(%rbx,%rdx,8)
test   %ecx,%ecx
sete   %dl
ucomisd %xmm5,%xmm2
seta   %bl
or     %dl,%bl
test   %bl,%bl
jne    1478 <cauchy_+0x308>
movapd %xmm2,%xmm5
mov    0x28(%rsp),%rdx
cmovne %eax,%edx
mov    %rdx,0x28(%rsp)
movapd %xmm5,%xmm2
mov    %rax,0x18(%rsp)
mov    0x1a8(%rsp),%rbx
mov    0x40(%rsp),%rcx
jmp    12df <cauchy_+0x16f>
cmp    $0x2,%eax
jl     1505 <cauchy_+0x395>
ucomisd %xmm4,%xmm9
jbe    1505 <cauchy_+0x395>
mov    0x18(%rsp),%rbx
movslq %ebx,%rax
add    $0x1,%ebx
mov    0x1a0(%rsp),%rdx
mov    %ebp,(%rdx,%rax,4)
movapd %xmm1,%xmm4
divsd  %xmm5,%xmm4
mov    0x1b0(%rsp),%rdx
movsd  %xmm4,(%rdx,%rax,8)
test   %eax,%eax
sete   %al
ucomisd %xmm4,%xmm2
seta   %dl
or     %al,%dl
test   %dl,%dl
jne    14ed <cauchy_+0x37d>
movapd %xmm2,%xmm4
mov    0x28(%rsp),%rax
mov    %rbx,0x18(%rsp)
cmovne %ebx,%eax
mov    %rax,0x28(%rsp)
movapd %xmm4,%xmm2
jmp    152e <cauchy_+0x3be>
mov    0x20(%rsp),%edx
movslq %edx,%rax
add    $0xffffffff,%edx
mov    %edx,0x20(%rsp)
mov    0x1a0(%rsp),%rdx
mov    %ebp,-0x8(%rdx,%rax,4)
ucomisd %xmm9,%xmm4
je     152e <cauchy_+0x3be>
movl   $0x0,0x34(%rsp)
mov    0x1a8(%rsp),%rbx
jmp    12df <cauchy_+0x16f>
mov    %r14d,%edi
xor    %eax,%eax
call   1030 <dcopy_@plt>
jmp    1cc1 <cauchy_+0xb51>
xor    %eax,%eax
mov    %rax,0x18(%rsp)
movl   $0x1,0x34(%rsp)
xorpd  %xmm3,%xmm3
mov    %ecx,0x20(%rsp)
xorpd  %xmm2,%xmm2
xor    %eax,%eax
mov    %rax,0x28(%rsp)
movapd %xmm2,0xc0(%rsp)
movapd %xmm3,0x40(%rsp)
ucomisd 0xa8d(%rip),%xmm0
mov    0xa0(%rsp),%rbp
jne    158f <cauchy_+0x41f>
jnp    15ae <cauchy_+0x43e>
mov    0x200(%rsp),%rax
add    $0xfffffffffffffff8,%rax
lea    0x8(%rax,%rbp,8),%rsi
mov    0x1f0(%rsp),%edi
mov    $0x1,%al
call   1060 <dscal_@plt>
mov    %r14d,%edi
mov    0x38(%rsp),%rsi
mov    0x1c0(%rsp),%rdx
xor    %eax,%eax
call   1030 <dcopy_@plt>
cmpl   $0x0,0x18(%rsp)
jne    15da <cauchy_+0x46a>
mov    0x20(%rsp),%eax
cmp    0x70(%rsp),%eax
je     1cc1 <cauchy_+0xb51>
mov    0x208(%rsp),%rdi
mov    0x1e0(%rsp),%r12
mov    0x1f0(%rsp),%ebx
test   %ebx,%ebx
jle    16c6 <cauchy_+0x556>
mov    0x14(%rsp),%eax
cmp    $0x2,%eax
mov    $0x1,%edx
cmovge %eax,%edx
shl    $0x3,%rdx
xor    %esi,%esi
call   1050 <memset@plt>
mov    0x240(%rsp),%rbx
mov    %rbx,(%rsp)
mov    0x1c8(%rsp),%edi
mov    %r12,%rsi
mov    0x1e8(%rsp),%rdx
mov    0x1f0(%rsp),%ecx
mov    0x200(%rsp),%r8
mov    0x218(%rsp),%r9
xor    %eax,%eax
call   1080 <bmv_@plt>
cmpl   $0x0,(%rbx)
jne    1cc1 <cauchy_+0xb51>
mov    %rbp,%r12
movapd 0x99d(%rip),%xmm0
xorpd  0x80(%rsp),%xmm0
movapd %xmm0,0x110(%rsp)
mulsd  0x40(%rsp),%xmm0
movapd %xmm0,0x70(%rsp)
mov    0x14(%rsp),%edi
mov    0x218(%rsp),%rsi
mov    0x200(%rsp),%rdx
xor    %eax,%eax
call   1040 <ddot_@plt>
movapd 0x40(%rsp),%xmm4
movapd 0x80(%rsp),%xmm9
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movapd 0x70(%rsp),%xmm5
subsd  %xmm0,%xmm5
mov    0x1f0(%rsp),%ebx
jmp    16fd <cauchy_+0x58d>
movapd 0x932(%rip),%xmm0
movapd 0x80(%rsp),%xmm9
xorpd  %xmm9,%xmm0
movapd %xmm0,0x110(%rsp)
movapd 0x40(%rsp),%xmm4
mulsd  %xmm4,%xmm0
movapd %xmm0,0x70(%rsp)
movapd %xmm0,%xmm5
mov    %rbp,%r12
mov    0x220(%rsp),%rax
movapd 0x8f3(%rip),%xmm1
xorpd  %xmm4,%xmm1
divsd  %xmm5,%xmm1
movl   $0x1,(%rax)
mov    0x18(%rsp),%rcx
test   %ecx,%ecx
mov    0x38(%rsp),%rdx
mov    0x58(%rsp),%r9
movapd 0xc0(%rsp),%xmm8
je     1c2f <cauchy_+0xabf>
mov    0x210(%rsp),%r8
movslq %ecx,%rbp
movslq 0x28(%rsp),%rax
mov    %rax,0xb0(%rsp)
movapd 0x70(%rsp),%xmm0
mulsd  0x60(%rsp),%xmm0
movapd %xmm0,0x70(%rsp)
lea    0x1(%rbx),%esi
test   %ecx,%ecx
mov    $0x1,%eax
cmovle %ecx,%eax
neg    %eax
add    %ecx,%eax
add    $0x1,%eax
mov    %eax,0x9c(%rsp)
lea    (%r8,%r12,8),%rax
mov    %rax,0xe0(%rsp)
add    $0xffffffffffffffff,%rsi
mov    %rsi,0xe8(%rsp)
mov    %rbp,0xd8(%rsp)
mov    %rbp,%rdi
mov    $0x1,%ebp
xorpd  %xmm2,%xmm2
xorpd  %xmm0,%xmm0
movsd  %xmm0,0x20(%rsp)
mov    0x200(%rsp),%rsi
nop
movapd %xmm8,%xmm10
mov    0xb0(%rsp),%rax
cmp    $0x1,%ebp
je     18b0 <cauchy_+0x740>
movsd  %xmm2,0x90(%rsp)
movapd %xmm1,0xa0(%rsp)
movapd %xmm5,0x60(%rsp)
movapd %xmm4,0x40(%rsp)
cmp    $0x2,%ebp
jne    1838 <cauchy_+0x6c8>
mov    0x18(%rsp),%rax
cmp    %eax,0x28(%rsp)
je     1838 <cauchy_+0x6c8>
mov    0x1b0(%rsp),%rax
mov    0xd8(%rsp),%rdx
movsd  -0x8(%rax,%rdx,8),%xmm0
mov    0xb0(%rsp),%rsi
movsd  %xmm0,-0x8(%rax,%rsi,8)
mov    0x1a0(%rsp),%rcx
mov    -0x4(%rcx,%rdx,4),%eax
mov    %eax,-0x4(%rcx,%rsi,4)
lea    -0x2(%rbp),%ecx
mov    0x1b0(%rsp),%r12
mov    %r12,%rsi
mov    0x1a0(%rsp),%rdx
xor    %eax,%eax
mov    %rdi,%rbx
call   1070 <hpsolb_@plt>
mov    %rbx,%rdi
movsd  -0x8(%r12,%rbx,8),%xmm10
mov    %rbx,%rax
mov    0x1f0(%rsp),%ebx
mov    0x38(%rsp),%rdx
mov    0x200(%rsp),%rsi
movapd 0x80(%rsp),%xmm9
mov    0x58(%rsp),%r9
movapd 0x40(%rsp),%xmm4
movapd 0xc0(%rsp),%xmm8
movapd 0x60(%rsp),%xmm5
movapd 0xa0(%rsp),%xmm1
movsd  0x90(%rsp),%xmm2
movapd %xmm10,%xmm0
subsd  %xmm2,%xmm0
ucomisd %xmm1,%xmm0
ja     1c35 <cauchy_+0xac5>
mov    0x1a0(%rsp),%rcx
movslq -0x4(%rcx,%rax,4),%r12
add    $0xffffffffffffffff,%rdi
mov    0x1b8(%rsp),%rcx
movsd  -0x8(%rcx,%r12,8),%xmm6
xor    %eax,%eax
ucomisd 0x72b(%rip),%xmm6
movq   $0x0,-0x8(%rcx,%r12,8)
mov    0xb8(%rsp),%rcx
cmova  %r9,%rcx
seta   %al
add    $0x1,%eax
movsd  -0x8(%rcx,%r12,8),%xmm7
movsd  -0x8(%rdx,%r12,8),%xmm1
mov    0x1c0(%rsp),%rcx
movsd  %xmm7,-0x8(%rcx,%r12,8)
mov    0x1a8(%rsp),%rcx
mov    %eax,-0x4(%rcx,%r12,4)
test   %edi,%edi
jne    1941 <cauchy_+0x7d1>
cmp    %r14d,0x18(%rsp)
je     1c3d <cauchy_+0xacd>
mov    0x220(%rsp),%rax
addl   $0x1,(%rax)
subsd  %xmm1,%xmm7
movapd %xmm6,%xmm3
mulsd  %xmm6,%xmm3
movapd %xmm0,%xmm1
mulsd  %xmm5,%xmm1
addsd  %xmm4,%xmm1
addsd  %xmm3,%xmm1
movapd %xmm6,%xmm2
mulsd  %xmm9,%xmm2
mulsd  %xmm7,%xmm2
movapd %xmm1,%xmm4
subsd  %xmm2,%xmm4
movapd 0x110(%rsp),%xmm7
mulsd  %xmm3,%xmm7
addsd  %xmm5,%xmm7
test   %ebx,%ebx
jle    1bc3 <cauchy_+0xa53>
movapd %xmm7,0x130(%rsp)
movapd %xmm3,0x140(%rsp)
movsd  %xmm10,0x108(%rsp)
mov    %rdi,0x90(%rsp)
mov    %rbp,0xa0(%rsp)
movapd %xmm4,0x40(%rsp)
movapd %xmm6,0x150(%rsp)
xorpd  0x627(%rip),%xmm6
movapd %xmm6,0x120(%rsp)
mov    0x14(%rsp),%edi
movapd %xmm0,0x60(%rsp)
mov    0x208(%rsp),%rdx
mov    $0x1,%al
call   1090 <daxpy_@plt>
xor    %ecx,%ecx
mov    0x1f8(%rsp),%edx
movapd 0x80(%rsp),%xmm1
mov    0x1c8(%rsp),%edi
mov    0x210(%rsp),%r8
mov    0xe8(%rsp),%rsi
mov    0xe0(%rsp),%rbp
nopl   0x0(%rax)
mov    %edx,%eax
imul   %r14d,%eax
add    %r12d,%eax
cltq
movsd  0x0(%r13,%rax,8),%xmm0
movsd  %xmm0,(%r8,%rcx,8)
movsd  (%r15,%rax,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x0(%rbp,%rcx,8)
mov    %edx,%eax
cltd
idiv   %edi
add    $0x1,%edx
add    $0x1,%rcx
cmp    %rcx,%rsi
jne    1a30 <cauchy_+0x8c0>
mov    0x240(%rsp),%r12
mov    %r12,(%rsp)
mov    0x1e0(%rsp),%rsi
mov    0x1e8(%rsp),%rdx
mov    0x1f0(%rsp),%ecx
mov    0x218(%rsp),%rbx
mov    %rbx,%r9
xor    %eax,%eax
call   1080 <bmv_@plt>
cmpl   $0x0,(%r12)
jne    1cc1 <cauchy_+0xb51>
mov    0x14(%rsp),%r12d
mov    %r12d,%edi
mov    0x208(%rsp),%rsi
mov    %rbx,%rdx
xor    %eax,%eax
call   1040 <ddot_@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x100(%rsp)
mov    %r12d,%edi
mov    0x200(%rsp),%rsi
mov    %rbx,%rdx
xor    %eax,%eax
call   1040 <ddot_@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0xf8(%rsp)
mov    %r12d,%edi
mov    0x210(%rsp),%rbp
mov    %rbp,%rsi
mov    %rbx,%rdx
xor    %eax,%eax
call   1040 <ddot_@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0xf0(%rsp)
mov    %r12d,%edi
movaps 0x120(%rsp),%xmm0
mov    %rbp,%rsi
mov    0x200(%rsp),%rdx
mov    $0x1,%al
call   1090 <daxpy_@plt>
movapd 0x150(%rsp),%xmm0
movsd  0x100(%rsp),%xmm1
mulsd  %xmm0,%xmm1
movapd 0x40(%rsp),%xmm4
addsd  %xmm1,%xmm4
addsd  %xmm0,%xmm0
mulsd  0xf8(%rsp),%xmm0
addsd  0x130(%rsp),%xmm0
movapd 0x140(%rsp),%xmm1
mulsd  0xf0(%rsp),%xmm1
subsd  %xmm1,%xmm0
movapd %xmm0,%xmm7
mov    0x1f0(%rsp),%ebx
mov    0x58(%rsp),%r9
movapd 0xc0(%rsp),%xmm8
mov    0xa0(%rsp),%rbp
mov    0x90(%rsp),%rdi
movsd  0x108(%rsp),%xmm10
movapd 0x60(%rsp),%xmm0
movsd  0x20(%rsp),%xmm2
addsd  %xmm0,%xmm2
movapd %xmm7,%xmm5
movapd 0x70(%rsp),%xmm1
cmplesd %xmm1,%xmm5
movapd %xmm5,%xmm0
andpd  %xmm1,%xmm0
andnpd %xmm7,%xmm5
orpd   %xmm0,%xmm5
cmp    0x9c(%rsp),%ebp
je     1c45 <cauchy_+0xad5>
movsd  %xmm2,0x20(%rsp)
add    $0x1,%ebp
movapd %xmm4,%xmm1
xorpd  0x3f6(%rip),%xmm1
divsd  %xmm5,%xmm1
movapd %xmm10,%xmm2
mov    0x38(%rsp),%rdx
mov    0x200(%rsp),%rsi
movapd 0x80(%rsp),%xmm9
jmp    17c0 <cauchy_+0x650>
xorpd  %xmm2,%xmm2
jmp    1c60 <cauchy_+0xaf0>
movsd  0x20(%rsp),%xmm2
jmp    1c60 <cauchy_+0xaf0>
movapd %xmm0,0x60(%rsp)
jmp    1c9c <cauchy_+0xb2c>
xorpd  %xmm1,%xmm1
cmpl   $0x0,0x34(%rsp)
jne    1c60 <cauchy_+0xaf0>
xorpd  0x3a8(%rip),%xmm4
divsd  %xmm5,%xmm4
movapd %xmm4,%xmm1
movapd %xmm1,%xmm0
cmplesd 0x3ab(%rip),%xmm0
andnpd %xmm1,%xmm0
movapd %xmm0,0x60(%rsp)
addsd  %xmm2,%xmm0
mov    %r14d,%edi
mov    0x1b8(%rsp),%rsi
mov    0x1c0(%rsp),%rdx
mov    $0x1,%al
call   1090 <daxpy_@plt>
mov    0x1f0(%rsp),%ebx
test   %ebx,%ebx
jle    1cc1 <cauchy_+0xb51>
mov    0x14(%rsp),%edi
movapd 0x60(%rsp),%xmm0
mov    0x200(%rsp),%rsi
mov    0x208(%rsp),%rdx
mov    $0x1,%al
call   1090 <daxpy_@plt>
xor    %eax,%eax
add    $0x168,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@cauchy_.tu = internal unnamed_addr global double 0.000000e+00
@cauchy_.tl = internal unnamed_addr global double 0.000000e+00
define i32 @cauchy_(i32 %0, double* %1, double* nocapture %2, double* nocapture %3, i32* nocapture %4, double* nocapture %5, i32* %6, i32* nocapture %7, double* %8, double* %9, double* %10, i32 %11, double* nocapture %12, double* nocapture %13, double* %14, double* %15, double %16, i32 %17, i32 %18, double* %19, double* %20, double* %21, double* %22, i32* nocapture %23, double* nocapture readnone %24, double* nocapture readnone %25, double* nocapture %26, i32* %27, double %28) {
%30 = bitcast double* %19 to i8*
%31 = bitcast double* %20 to i8*
%32 = getelementptr inbounds double, double* %10, i64 -1
%33 = getelementptr inbounds double, double* %9, i64 -1
%34 = getelementptr inbounds double, double* %8, i64 -1
%35 = getelementptr inbounds i32, i32* %7, i64 -1
%36 = getelementptr inbounds i32, i32* %6, i64 -1
%37 = getelementptr inbounds double, double* %5, i64 -1
%38 = getelementptr inbounds i32, i32* %4, i64 -1
%39 = getelementptr inbounds double, double* %3, i64 -1
%40 = getelementptr inbounds double, double* %2, i64 -1
%41 = getelementptr inbounds double, double* %1, i64 -1
%42 = getelementptr inbounds double, double* %21, i64 -1
%43 = getelementptr inbounds double, double* %19, i64 -1
%44 = add i32 %0, 1
%45 = xor i32 %0, -1
%46 = sext i32 %45 to i64
%47 = getelementptr inbounds double, double* %13, i64 %46
%48 = getelementptr inbounds double, double* %12, i64 %46
%49 = load double, double* %26
%50 = fcmp ugt double %49, 0.000000e+00
br i1 %50, label %53, label %51
51: ; preds = %29
%52 = tail call i32 (i32, double*, double*, ...) bitcast (i32 (...)* @dcopy_ to i32 (i32, double*, double*, ...)*)(i32 %0, double* %1, double* %10)
br label %378
53: ; preds = %29
%54 = shl i32 %17, 1
%55 = icmp slt i32 %17, 1
br i1 %55, label %60, label %56
56: ; preds = %53
%57 = call i32 @llvm.smax.i32(i32 %54, i32 1)
%58 = zext i32 %57 to i64
%59 = shl nuw nsw i64 %58, 3
br label %60
60: ; preds = %56, %53
%61 = icmp slt i32 %0, 1
br i1 %61, label %203, label %62
62: ; preds = %60
%63 = load double, double* @cauchy_.tu
%64 = load double, double* @cauchy_.tl
%65 = sext i32 %17 to i64
%66 = add i32 %17, 1
%67 = zext i32 %44 to i64
%68 = zext i32 %66 to i64
br label %69
69: ; preds = %62, %192
%70 = phi i64 [ 1, %62 ], [ %201, %192 ]
%71 = phi i32 [ 0, %62 ], [ %200, %192 ]
%72 = phi i32 [ 0, %62 ], [ %199, %192 ]
%73 = phi double [ 0.000000e+00, %62 ], [ %198, %192 ]
%74 = phi i32 [ %44, %62 ], [ %197, %192 ]
%75 = phi i32 [ 1, %62 ], [ %196, %192 ]
%76 = phi double [ 0.000000e+00, %62 ], [ %195, %192 ]
%77 = phi double [ %64, %62 ], [ %194, %192 ]
%78 = phi double [ %63, %62 ], [ %193, %192 ]
%79 = getelementptr inbounds double, double* %37, i64 %70
%80 = load double, double* %79
%81 = fneg double %80
%82 = getelementptr inbounds i32, i32* %35, i64 %70
%83 = load i32, i32* %82
switch i32 %83, label %84 [
i32 -1, label %121
i32 3, label %117
]
84: ; preds = %69
%85 = getelementptr inbounds i32, i32* %38, i64 %70
%86 = load i32, i32* %85
%87 = icmp slt i32 %86, 3
%88 = getelementptr inbounds double, double* %41, i64 %70
%89 = load double, double* %88
br i1 %87, label %90, label %95
90: ; preds = %84
%91 = getelementptr inbounds double, double* %40, i64 %70
%92 = load double, double* %91
%93 = fsub double %89, %92
store double %93, double* @cauchy_.tl
%94 = icmp eq i32 %86, 2
br i1 %94, label %95, label %100
95: ; preds = %84, %90
%96 = phi double [ %93, %90 ], [ %77, %84 ]
%97 = getelementptr inbounds double, double* %39, i64 %70
%98 = load double, double* %97
%99 = fsub double %98, %89
store double %99, double* @cauchy_.tu
br label %100
100: ; preds = %95, %90
%101 = phi double [ %99, %95 ], [ %78, %90 ]
%102 = phi double [ %96, %95 ], [ %93, %90 ]
%103 = phi i1 [ true, %95 ], [ false, %90 ]
%104 = fcmp ole double %102, 0.000000e+00
%105 = select i1 %87, i1 %104, i1 false
store i32 0, i32* %82
br i1 %105, label %106, label %108
106: ; preds = %100
%107 = fcmp ult double %80, 0.000000e+00
br i1 %107, label %121, label %115
108: ; preds = %100
%109 = fcmp ole double %101, 0.000000e+00
%110 = select i1 %103, i1 %109, i1 false
br i1 %110, label %111, label %113
111: ; preds = %108
%112 = fcmp ugt double %80, 0.000000e+00
br i1 %112, label %121, label %115
113: ; preds = %108
%114 = fcmp oeq double %80, 0.000000e+00
br i1 %114, label %115, label %121
115: ; preds = %113, %111, %106
%116 = phi i32 [ 1, %106 ], [ 2, %111 ], [ -3, %113 ]
store i32 %116, i32* %82
br label %117
117: ; preds = %115, %69
%118 = phi double [ %78, %69 ], [ %101, %115 ]
%119 = phi double [ %77, %69 ], [ %102, %115 ]
%120 = getelementptr inbounds double, double* %33, i64 %70
store double 0.000000e+00, double* %120
br label %192
121: ; preds = %69, %113, %111, %106
%122 = phi double [ %101, %106 ], [ %101, %111 ], [ %101, %113 ], [ %78, %69 ]
%123 = phi double [ %102, %106 ], [ %102, %111 ], [ %102, %113 ], [ %77, %69 ]
%124 = getelementptr inbounds double, double* %33, i64 %70
store double %81, double* %124
%125 = tail call double @llvm.fmuladd.f64(double %80, double %81, double %76)
br i1 %55, label %149, label %126
126: ; preds = %121
%127 = trunc i64 %70 to i32
br label %128
128: ; preds = %126, %128
%129 = phi i64 [ 1, %126 ], [ %147, %128 ]
%130 = phi i32 [ %18, %126 ], [ %146, %128 ]
%131 = mul nsw i32 %130, %0
%132 = add nsw i32 %131, %127
%133 = sext i32 %132 to i64
%134 = getelementptr inbounds double, double* %48, i64 %133
%135 = load double, double* %134
%136 = getelementptr inbounds double, double* %43, i64 %129
%137 = load double, double* %136
%138 = tail call double @llvm.fmuladd.f64(double %135, double %81, double %137)
store double %138, double* %136
%139 = getelementptr inbounds double, double* %47, i64 %133
%140 = load double, double* %139
%141 = add nsw i64 %129, %65
%142 = getelementptr inbounds double, double* %43, i64 %141
%143 = load double, double* %142
%144 = tail call double @llvm.fmuladd.f64(double %140, double %81, double %143)
store double %144, double* %142
%145 = srem i32 %130, %11
%146 = add nsw i32 %145, 1
%147 = add nuw nsw i64 %129, 1
%148 = icmp eq i64 %147, %68
br i1 %148, label %149, label %128
149: ; preds = %128, %121
%150 = getelementptr inbounds i32, i32* %38, i64 %70
%151 = load i32, i32* %150
%152 = icmp slt i32 %151, 3
br i1 %152, label %153, label %169
153: ; preds = %149
%154 = icmp ne i32 %151, 0
%155 = fcmp ogt double %80, 0.000000e+00
%156 = select i1 %154, i1 %155, i1 false
br i1 %156, label %157, label %169
157: ; preds = %153
%158 = add nsw i32 %72, 1
%159 = sext i32 %158 to i64
%160 = getelementptr inbounds i32, i32* %36, i64 %159
%161 = trunc i64 %70 to i32
store i32 %161, i32* %160
%162 = fdiv double %123, %80
%163 = getelementptr inbounds double, double* %34, i64 %159
store double %162, double* %163
%164 = icmp eq i32 %72, 0
%165 = fcmp olt double %162, %73
%166 = select i1 %164, i1 true, i1 %165
%167 = select i1 %166, double %162, double %73
%168 = select i1 %166, i32 %158, i32 %71
br label %192
169: ; preds = %153, %149
%170 = icmp sgt i32 %151, 1
%171 = fcmp olt double %80, 0.000000e+00
%172 = select i1 %170, i1 %171, i1 false
br i1 %172, label %173, label %185
173: ; preds = %169
%174 = add nsw i32 %72, 1
%175 = sext i32 %174 to i64
%176 = getelementptr inbounds i32, i32* %36, i64 %175
%177 = trunc i64 %70 to i32
store i32 %177, i32* %176
%178 = fdiv double %122, %81
%179 = getelementptr inbounds double, double* %34, i64 %175
store double %178, double* %179
%180 = icmp eq i32 %72, 0
%181 = fcmp olt double %178, %73
%182 = select i1 %180, i1 true, i1 %181
%183 = select i1 %182, double %178, double %73
%184 = select i1 %182, i32 %174, i32 %71
br label %192
185: ; preds = %169
%186 = add nsw i32 %74, -1
%187 = sext i32 %186 to i64
%188 = getelementptr inbounds i32, i32* %36, i64 %187
%189 = trunc i64 %70 to i32
store i32 %189, i32* %188
%190 = fcmp ueq double %80, 0.000000e+00
br i1 %190, label %192, label %191
191: ; preds = %185
br label %192
192: ; preds = %173, %157, %117, %191, %185
%193 = phi double [ %118, %117 ], [ %122, %191 ], [ %122, %185 ], [ %122, %157 ], [ %122, %173 ]
%194 = phi double [ %119, %117 ], [ %123, %191 ], [ %123, %185 ], [ %123, %157 ], [ %123, %173 ]
%195 = phi double [ %76, %117 ], [ %125, %191 ], [ %125, %185 ], [ %125, %157 ], [ %125, %173 ]
%196 = phi i32 [ %75, %117 ], [ 0, %191 ], [ %75, %185 ], [ %75, %157 ], [ %75, %173 ]
%197 = phi i32 [ %74, %117 ], [ %186, %191 ], [ %186, %185 ], [ %74, %157 ], [ %74, %173 ]
%198 = phi double [ %73, %117 ], [ %73, %191 ], [ %73, %185 ], [ %167, %157 ], [ %183, %173 ]
%199 = phi i32 [ %72, %117 ], [ %72, %191 ], [ %72, %185 ], [ %158, %157 ], [ %174, %173 ]
%200 = phi i32 [ %71, %117 ], [ %71, %191 ], [ %71, %185 ], [ %168, %157 ], [ %184, %173 ]
%201 = add nuw nsw i64 %70, 1
%202 = icmp eq i64 %201, %67
br i1 %202, label %203, label %69
203: ; preds = %192, %60
%204 = phi double [ 0.000000e+00, %60 ], [ %195, %192 ]
%205 = phi i32 [ 1, %60 ], [ %196, %192 ]
%206 = phi i32 [ %44, %60 ], [ %197, %192 ]
%207 = phi double [ 0.000000e+00, %60 ], [ %198, %192 ]
%208 = phi i32 [ 0, %60 ], [ %199, %192 ]
%209 = phi i32 [ 0, %60 ], [ %200, %192 ]
%210 = fcmp une double %16, 1.000000e+00
br i1 %210, label %211, label %216
211: ; preds = %203
%212 = add nsw i32 %17, 1
%213 = sext i32 %212 to i64
%214 = getelementptr inbounds double, double* %43, i64 %213
%215 = tail call i32 (i32, double, double*, ...) bitcast (i32 (...)* @dscal_ to i32 (i32, double, double*, ...)*)(i32 %17, double %16, double* %214)
br label %216
216: ; preds = %211, %203
%217 = tail call i32 (i32, double*, double*, ...) bitcast (i32 (...)* @dcopy_ to i32 (i32, double*, double*, ...)*)(i32 %0, double* %1, double* %10)
%218 = icmp eq i32 %208, 0
%219 = icmp eq i32 %206, %44
%220 = select i1 %218, i1 %219, i1 false
br i1 %220, label %378, label %221
221: ; preds = %216
br i1 %55, label %222, label %225
222: ; preds = %221
%223 = fneg double %16
%224 = fmul double %204, %223
br label %238
225: ; preds = %221
%226 = call i32 @llvm.smax.i32(i32 %54, i32 1)
%227 = zext i32 %226 to i64
%228 = shl nuw nsw i64 %227, 3
%229 = fneg double %16
%230 = fmul double %204, %229
%231 = tail call i32 (i32, double*, double*, i32, double*, double*, i32*, ...) bitcast (i32 (...)* @bmv_ to i32 (i32, double*, double*, i32, double*, double*, i32*, ...)*)(i32 %11, double* %14, double* %15, i32 %17, double* %19, double* %22, i32* %27)
%232 = load i32, i32* %27
%233 = icmp eq i32 %232, 0
br i1 %233, label %234, label %378
234: ; preds = %225
%235 = tail call i32 (i32, double*, double*, ...) bitcast (i32 (...)* @ddot_ to i32 (i32, double*, double*, ...)*)(i32 %54, double* %22, double* %19)
%236 = sitofp i32 %235 to double
%237 = fsub double %230, %236
br label %238
238: ; preds = %222, %234
%239 = phi double [ %230, %234 ], [ %224, %222 ]
%240 = phi double [ %229, %234 ], [ %223, %222 ]
%241 = phi double [ %237, %234 ], [ %224, %222 ]
%242 = fneg double %204
%243 = fdiv double %242, %241
store i32 1, i32* %23
br i1 %218, label %367, label %244
244: ; preds = %238
%245 = icmp eq i32 %209, %208
%246 = sext i32 %208 to i64
%247 = getelementptr inbounds double, double* %34, i64 %246
%248 = sext i32 %209 to i64
%249 = getelementptr inbounds double, double* %34, i64 %248
%250 = getelementptr inbounds i32, i32* %36, i64 %246
%251 = getelementptr inbounds i32, i32* %36, i64 %248
%252 = icmp eq i32 %208, %0
%253 = fmul double %239, %28
%254 = sext i32 %17 to i64
%255 = add i32 %17, 1
%256 = add i32 %208, 1
%257 = call i32 @llvm.smin.i32(i32 %208, i32 1)
%258 = sub i32 %256, %257
%259 = zext i32 %255 to i64
br label %260
260: ; preds = %244, %359
%261 = phi i64 [ %246, %244 ], [ %287, %359 ]
%262 = phi double [ %204, %244 ], [ %354, %359 ]
%263 = phi double [ %241, %244 ], [ %357, %359 ]
%264 = phi double [ 0.000000e+00, %244 ], [ %279, %359 ]
%265 = phi double [ %243, %244 ], [ %361, %359 ]
%266 = phi i32 [ 1, %244 ], [ %288, %359 ]
%267 = phi double [ 0.000000e+00, %244 ], [ %286, %359 ]
switch i32 %266, label %272 [
i32 1, label %278
i32 2, label %268
]
268: ; preds = %260
br i1 %245, label %272, label %269
269: ; preds = %268
%270 = load double, double* %247
store double %270, double* %249
%271 = load i32, i32* %250
store i32 %271, i32* %251
br label %272
272: ; preds = %260, %268, %269
%273 = add nsw i32 %266, -2
%274 = trunc i64 %261 to i32
%275 = tail call i32 (i32, double*, i32*, i32, ...) bitcast (i32 (...)* @hpsolb_ to i32 (i32, double*, i32*, i32, ...)*)(i32 %274, double* %8, i32* %6, i32 %273)
%276 = getelementptr inbounds double, double* %34, i64 %261
%277 = load double, double* %276
br label %278
278: ; preds = %260, %272
%279 = phi double [ %277, %272 ], [ %207, %260 ]
%280 = phi i64 [ %261, %272 ], [ %248, %260 ]
%281 = getelementptr inbounds i32, i32* %36, i64 %280
%282 = load i32, i32* %281
%283 = fsub double %279, %264
%284 = fcmp olt double %265, %283
br i1 %284, label %367, label %285
285: ; preds = %278
%286 = fadd double %267, %283
%287 = add nsw i64 %261, -1
%288 = add nuw i32 %266, 1
%289 = sext i32 %282 to i64
%290 = getelementptr inbounds double, double* %33, i64 %289
%291 = load double, double* %290
store double 0.000000e+00, double* %290
%292 = fcmp ogt double %291, 0.000000e+00
%293 = select i1 %292, double* %3, double* %2
%294 = select i1 %292, i32 2, i32 1
%295 = getelementptr inbounds double, double* %293, i64 -1
%296 = getelementptr inbounds double, double* %295, i64 %289
%297 = load double, double* %296
%298 = getelementptr inbounds double, double* %41, i64 %289
%299 = load double, double* %298
%300 = getelementptr inbounds double, double* %32, i64 %289
store double %297, double* %300
%301 = getelementptr inbounds i32, i32* %35, i64 %289
store i32 %294, i32* %301
%302 = trunc i64 %287 to i32
%303 = icmp eq i32 %302, 0
%304 = select i1 %303, i1 %252, i1 false
br i1 %304, label %374, label %305
305: ; preds = %285
%306 = fsub double %297, %299
%307 = load i32, i32* %23
%308 = add nsw i32 %307, 1
store i32 %308, i32* %23
%309 = fmul double %291, %291
%310 = tail call double @llvm.fmuladd.f64(double %283, double %263, double %262)
%311 = fadd double %310, %309
%312 = fneg double %291
%313 = fmul double %312, %16
%314 = tail call double @llvm.fmuladd.f64(double %313, double %306, double %311)
%315 = tail call double @llvm.fmuladd.f64(double %240, double %309, double %263)
br i1 %55, label %353, label %316
316: ; preds = %305
%317 = tail call i32 (i32, double, double*, double*, ...) bitcast (i32 (...)* @daxpy_ to i32 (i32, double, double*, double*, ...)*)(i32 %54, double %283, double* %19, double* %20)
br label %318
318: ; preds = %316, %318
%319 = phi i64 [ %334, %318 ], [ 1, %316 ]
%320 = phi i32 [ %333, %318 ], [ %18, %316 ]
%321 = mul nsw i32 %320, %0
%322 = add nsw i32 %321, %282
%323 = sext i32 %322 to i64
%324 = getelementptr inbounds double, double* %48, i64 %323
%325 = load double, double* %324
%326 = getelementptr inbounds double, double* %42, i64 %319
store double %325, double* %326
%327 = getelementptr inbounds double, double* %47, i64 %323
%328 = load double, double* %327
%329 = fmul double %328, %16
%330 = add nsw i64 %319, %254
%331 = getelementptr inbounds double, double* %42, i64 %330
store double %329, double* %331
%332 = srem i32 %320, %11
%333 = add nsw i32 %332, 1
%334 = add nuw nsw i64 %319, 1
%335 = icmp eq i64 %334, %259
br i1 %335, label %336, label %318
336: ; preds = %318
%337 = tail call i32 (i32, double*, double*, i32, double*, double*, i32*, ...) bitcast (i32 (...)* @bmv_ to i32 (i32, double*, double*, i32, double*, double*, i32*, ...)*)(i32 %11, double* %14, double* %15, i32 %17, double* %21, double* %22, i32* %27)
%338 = load i32, i32* %27
%339 = icmp eq i32 %338, 0
br i1 %339, label %340, label %378
340: ; preds = %336
%341 = tail call i32 (i32, double*, double*, ...) bitcast (i32 (...)* @ddot_ to i32 (i32, double*, double*, ...)*)(i32 %54, double* %20, double* %22)
%342 = sitofp i32 %341 to double
%343 = tail call i32 (i32, double*, double*, ...) bitcast (i32 (...)* @ddot_ to i32 (i32, double*, double*, ...)*)(i32 %54, double* %19, double* %22)
%344 = sitofp i32 %343 to double
%345 = tail call i32 (i32, double*, double*, ...) bitcast (i32 (...)* @ddot_ to i32 (i32, double*, double*, ...)*)(i32 %54, double* %21, double* %22)
%346 = sitofp i32 %345 to double
%347 = tail call i32 (i32, double, double*, double*, ...) bitcast (i32 (...)* @daxpy_ to i32 (i32, double, double*, double*, ...)*)(i32 %54, double %312, double* %21, double* %19)
%348 = tail call double @llvm.fmuladd.f64(double %291, double %342, double %314)
%349 = fmul double %291, 2.000000e+00
%350 = tail call double @llvm.fmuladd.f64(double %349, double %344, double %315)
%351 = fneg double %309
%352 = tail call double @llvm.fmuladd.f64(double %351, double %346, double %350)
br label %353
353: ; preds = %340, %305
%354 = phi double [ %348, %340 ], [ %314, %305 ]
%355 = phi double [ %352, %340 ], [ %315, %305 ]
%356 = fcmp oge double %253, %355
%357 = select i1 %356, double %253, double %355
%358 = icmp eq i32 %266, %258
br i1 %358, label %362, label %359
359: ; preds = %353
%360 = fneg double %354
%361 = fdiv double %360, %357
br label %260
362: ; preds = %353
%363 = icmp eq i32 %205, 0
br i1 %363, label %364, label %367
364: ; preds = %362
%365 = fneg double %354
%366 = fdiv double %365, %357
br label %367
367: ; preds = %278, %362, %364, %238
%368 = phi double [ %243, %238 ], [ %366, %364 ], [ 0.000000e+00, %362 ], [ %265, %278 ]
%369 = phi double [ 0.000000e+00, %238 ], [ %286, %364 ], [ %286, %362 ], [ %267, %278 ]
%370 = fcmp ole double %368, 0.000000e+00
%371 = select i1 %370, double 0.000000e+00, double %368
%372 = fadd double %369, %371
%373 = tail call i32 (i32, double, double*, double*, ...) bitcast (i32 (...)* @daxpy_ to i32 (i32, double, double*, double*, ...)*)(i32 %0, double %372, double* %9, double* %10)
br label %374
374: ; preds = %285, %367
%375 = phi double [ %371, %367 ], [ %283, %285 ]
br i1 %55, label %378, label %376
376: ; preds = %374
%377 = tail call i32 (i32, double, double*, double*, ...) bitcast (i32 (...)* @daxpy_ to i32 (i32, double, double*, double*, ...)*)(i32 %54, double %375, double* %19, double* %20)
br label %378
378: ; preds = %336, %374, %376, %225, %216, %51
ret i32 0
}