int SBL(double *y, int *I, double *alpha, double *w, double *sigw, int M,
        int *pK, double sigma2, double a, double b, double maxalpha, int maxit,
        double tol, int debug) {
  int n, i, K;
  int M0, sizesel;
  double *w0;
  double mynorm, myaux;
  double *h0;
  double *h1;
  double *xx;
  double *z;
  double *t0;
  double *tl;
  double *tu;
  double *wpred;
  double *d;
  double *e;
  int *sel;
  double *AA;
  double *yy;
  K = *pK;
  M0 = M - 1;
  if (K == 0) {
    w[0] = -1;
    *pK = K;
    sigw[0] = -1;
    return 0;
  }
  yy = calloc(M, sizeof(double));
  t0 = calloc(M, sizeof(double));
  tl = calloc(M - 1, sizeof(double));
  tu = calloc(M - 1, sizeof(double));
  AA = calloc(4 * M, sizeof(double));
  d = calloc(M0 - 1, sizeof(double));
  e = calloc(M0 - 1, sizeof(double));
  h0 = calloc(M0, sizeof(double));
  h1 = calloc(M0 - 1, sizeof(double));
  wpred = calloc(K, sizeof(double));
  sel = calloc(K, sizeof(int));
  z = calloc(M0, sizeof(double));
  xx = calloc(K, sizeof(double));
  for (i = 0; i < M; i++)
    yy[i] = y[i];
  ComputeH(h0, h1, M);
  ComputeFdualXb(M, yy);
  w0 = yy;
  for (i = 0; i < K; i++) {
    xx[i] = w0[i];
    t0[i] = h0[i];
  }
  TrisolveREG(t0, h1, h1, xx, z, M0);
  if (K < M0) {
    ComputeHs(I, M, K, h0, h1);
    for (i = 0; i < K; i++)
      t0[i] = z[I[i]];
    for (i = 0; i < K; i++)
      xx[i] = 0;
    TriSymGaxpy(h0, h1, t0, K, xx);
    w0 = xx;
  }
  for (n = 0; n < maxit; n++) {
    for (i = 0; i < K; i++) {
      wpred[i] = w[i];
    }
    ComputeT(h0, h1, K, alpha, sigma2, t0, tl, tu);
    if (K == 1) {
      w[0] = w0[0] / t0[0];
      sigw[0] = 1 / t0[0] * h0[0] * sigma2;
    } else {
      for (i = 0; i < K; i++) {
        if (i != K - 1) {
          AA[(i << 2)] = tu[i];
          AA[(i << 2) + 2] = tl[i];
        }
        AA[(i << 2) + 1] = t0[i];
        AA[(i << 2) + 3] = w0[i];
      }
      TriSolveINV(AA, 4, K, w, d, e);
      tridiagofinverse(t0, tl, tl, t0, tu, K, d, e);
      DiagOfTriXTri(tl, t0, tu, h1, h0, h1, sigw, K);
      for (i = 0; i < K; i++) {
        sigw[i] = sigma2 * sigw[i];
      }
    }
    for (i = 0; i < K; i++) {
      alpha[i] = (1 + 2 * a) / (w[i] * w[i] + sigw[i] + 2 * b);
    }
    mynorm = 0;
    for (i = 0; i < K; i++) {
      myaux = (wpred[i] - w[i]);
      if (myaux < 0)
        myaux = -myaux;
      if (myaux > mynorm)
        mynorm = myaux;
    }
    if (mynorm < tol) {
      if (debug > 0) {
        printf("#      SBL: Converged after %d iterations within tolerance %g, "
               "M=%d \n",
               n, tol, K);
      }
      break;
    }
    sizesel = findminus(alpha, K, maxalpha, sel);
    if (sizesel == 0) {
      K = 0;
      w[0] = -1;
      I[0] = -1;
      sigw[0] = -1;
      alpha[0] = -1;
      printf("#      SBL: After %d iterations, No disconinuities found M=%d \n",
             n, K);
      break;
    }
    if (sizesel < K) {
      K = sizesel;
      for (i = 0; i < sizesel; i++)
        I[i] = I[sel[i]];
      ComputeHs(I, M, K, h0, h1);
      for (i = 0; i < K; i++)
        alpha[i] = alpha[sel[i]];
      for (i = 0; i < K; i++)
        t0[i] = z[I[i]];
      for (i = 0; i < K; i++)
        xx[i] = 0;
      TriSymGaxpy(h0, h1, t0, K, xx);
      w0 = xx;
      for (i = 0; i < K; i++) {
        w[i] = w[sel[i]];
        wpred[i] = wpred[sel[i]];
      }
    }
  }
  if (debug > 0) {
    if (i >= maxit) {
      printf("#      SBL: Converged??? Stopped after %d iterations with change "
             "%g, M=%d\n",
             n, mynorm, K);
    }
  }
  if (K != 0) {
    for (i = 0; i < K; i++)
      t0[i] = z[I[i]];
    for (i = 0; i < K; i++)
      sigw[i] = h0[i];
    for (i = 0; i < K; i++)
      w[i] = 0;
    TriSymGaxpy(h0, h1, t0, K, w);
  } else {
    h0[0] = -1;
  }
  free(yy);
  free(h0);
  free(h1);
  free(xx);
  free(z);
  free(t0);
  free(tl);
  free(tu);
  free(wpred);
  free(d);
  free(e);
  free(sel);
  free(AA);
  *pK = K;
  return n;
}


x86 assembly (clang, -O0):
<SBL>:
push   %rbp
mov    %rsp,%rbp
sub    $0x110,%rsp
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%rax
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9d,-0x34(%rbp)
movsd  %xmm0,-0x40(%rbp)
movsd  %xmm1,-0x48(%rbp)
movsd  %xmm2,-0x50(%rbp)
movsd  %xmm3,-0x58(%rbp)
movsd  %xmm4,-0x60(%rbp)
mov    0x10(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x34(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x70(%rbp)
cmpl   $0x0,-0x6c(%rbp)
jne    1267 <SBL+0x97>
mov    -0x28(%rbp),%rax
movsd  0xdca(%rip),%xmm0
movsd  %xmm0,(%rax)
mov    -0x6c(%rbp),%ecx
mov    0x10(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x30(%rbp),%rax
movsd  0xdb1(%rip),%xmm0
movsd  %xmm0,(%rax)
movl   $0x0,-0x4(%rbp)
jmp    1dd1 <SBL+0xc01>
movslq -0x34(%rbp),%rdi
mov    $0x8,%esi
call   1080 <calloc@plt>
mov    %rax,-0xf8(%rbp)
movslq -0x34(%rbp),%rdi
mov    $0x8,%esi
call   1080 <calloc@plt>
mov    %rax,-0xb8(%rbp)
mov    -0x34(%rbp),%eax
sub    $0x1,%eax
movslq %eax,%rdi
mov    $0x8,%esi
call   1080 <calloc@plt>
mov    %rax,-0xc0(%rbp)
mov    -0x34(%rbp),%eax
sub    $0x1,%eax
movslq %eax,%rdi
mov    $0x8,%esi
call   1080 <calloc@plt>
mov    %rax,-0xc8(%rbp)
mov    -0x34(%rbp),%eax
shl    $0x2,%eax
movslq %eax,%rdi
mov    $0x8,%esi
call   1080 <calloc@plt>
mov    %rax,-0xf0(%rbp)
mov    -0x70(%rbp),%eax
sub    $0x1,%eax
movslq %eax,%rdi
mov    $0x8,%esi
call   1080 <calloc@plt>
mov    %rax,-0xd8(%rbp)
mov    -0x70(%rbp),%eax
sub    $0x1,%eax
movslq %eax,%rdi
mov    $0x8,%esi
call   1080 <calloc@plt>
mov    %rax,-0xe0(%rbp)
movslq -0x70(%rbp),%rdi
mov    $0x8,%esi
call   1080 <calloc@plt>
mov    %rax,-0x98(%rbp)
mov    -0x70(%rbp),%eax
sub    $0x1,%eax
movslq %eax,%rdi
mov    $0x8,%esi
call   1080 <calloc@plt>
mov    %rax,-0xa0(%rbp)
movslq -0x6c(%rbp),%rdi
mov    $0x8,%esi
call   1080 <calloc@plt>
mov    %rax,-0xd0(%rbp)
movslq -0x6c(%rbp),%rdi
mov    $0x4,%esi
call   1080 <calloc@plt>
mov    %rax,-0xe8(%rbp)
movslq -0x70(%rbp),%rdi
mov    $0x8,%esi
call   1080 <calloc@plt>
mov    %rax,-0xb0(%rbp)
movslq -0x6c(%rbp),%rdi
mov    $0x8,%esi
call   1080 <calloc@plt>
mov    %rax,-0xa8(%rbp)
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    13d4 <SBL+0x204>
mov    -0x10(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xf8(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    139d <SBL+0x1cd>
mov    -0x98(%rbp),%rdi
mov    -0xa0(%rbp),%rsi
mov    -0x34(%rbp),%edx
mov    $0x0,%al
call   1040 <ComputeH@plt>
mov    -0x34(%rbp),%edi
mov    -0xf8(%rbp),%rsi
mov    $0x0,%al
call   10e0 <ComputeFdualXb@plt>
mov    -0xf8(%rbp),%rax
mov    %rax,-0x80(%rbp)
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jge    1466 <SBL+0x296>
mov    -0x80(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xa8(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x98(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xb8(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    140f <SBL+0x23f>
mov    -0xb8(%rbp),%rdi
mov    -0xa0(%rbp),%rsi
mov    -0xa0(%rbp),%rdx
mov    -0xa8(%rbp),%rcx
mov    -0xb0(%rbp),%r8
mov    -0x70(%rbp),%r9d
mov    $0x0,%al
call   10d0 <TrisolveREG@plt>
mov    -0x6c(%rbp),%eax
cmp    -0x70(%rbp),%eax
jge    156d <SBL+0x39d>
mov    -0x18(%rbp),%rdi
mov    -0x34(%rbp),%esi
mov    -0x6c(%rbp),%edx
mov    -0x98(%rbp),%rcx
mov    -0xa0(%rbp),%r8
mov    $0x0,%al
call   10c0 <ComputeHs@plt>
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jge    1508 <SBL+0x338>
mov    -0xb0(%rbp),%rax
mov    -0x18(%rbp),%rcx
movslq -0x68(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xb8(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    14c6 <SBL+0x2f6>
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jge    153c <SBL+0x36c>
mov    -0xa8(%rbp),%rax
movslq -0x68(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    150f <SBL+0x33f>
mov    -0x98(%rbp),%rdi
mov    -0xa0(%rbp),%rsi
mov    -0xb8(%rbp),%rdx
mov    -0x6c(%rbp),%ecx
mov    -0xa8(%rbp),%r8
mov    $0x0,%al
call   1060 <TriSymGaxpy@plt>
mov    -0xa8(%rbp),%rax
mov    %rax,-0x80(%rbp)
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1bf2 <SBL+0xa22>
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jge    15be <SBL+0x3ee>
mov    -0x28(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xd0(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1587 <SBL+0x3b7>
mov    -0x98(%rbp),%rdi
mov    -0xa0(%rbp),%rsi
mov    -0x6c(%rbp),%edx
mov    -0x20(%rbp),%rcx
movsd  -0x40(%rbp),%xmm0
mov    -0xb8(%rbp),%r8
mov    -0xc0(%rbp),%r9
mov    -0xc8(%rbp),%rax
mov    %rax,(%rsp)
mov    $0x1,%al
call   1070 <ComputeT@plt>
cmpl   $0x1,-0x6c(%rbp)
jne    164d <SBL+0x47d>
mov    -0x80(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0xb8(%rbp),%rax
divsd  (%rax),%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0xb8(%rbp),%rax
movsd  0x9d4(%rip),%xmm0
divsd  (%rax),%xmm0
mov    -0x98(%rbp),%rax
mulsd  (%rax),%xmm0
mulsd  -0x40(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,(%rax)
jmp    180b <SBL+0x63b>
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jge    1719 <SBL+0x549>
mov    -0x68(%rbp),%eax
mov    -0x6c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
je     16be <SBL+0x4ee>
mov    -0xc8(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xf0(%rbp),%rax
mov    -0x68(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc0(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xf0(%rbp),%rax
mov    -0x68(%rbp),%ecx
shl    $0x2,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xb8(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xf0(%rbp),%rax
mov    -0x68(%rbp),%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x80(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xf0(%rbp),%rax
mov    -0x68(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1654 <SBL+0x484>
mov    -0xf0(%rbp),%rdi
mov    -0x6c(%rbp),%edx
mov    -0x28(%rbp),%rcx
mov    -0xd8(%rbp),%r8
mov    -0xe0(%rbp),%r9
mov    $0x4,%esi
mov    $0x0,%al
call   10b0 <TriSolveINV@plt>
mov    -0xb8(%rbp),%rdi
mov    -0xc0(%rbp),%rsi
mov    -0xc0(%rbp),%rdx
mov    -0xb8(%rbp),%rcx
mov    -0xc8(%rbp),%r8
mov    -0x6c(%rbp),%r9d
mov    -0xd8(%rbp),%r10
mov    -0xe0(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1090 <tridiagofinverse@plt>
mov    -0xc0(%rbp),%rdi
mov    -0xb8(%rbp),%rsi
mov    -0xc8(%rbp),%rdx
mov    -0xa0(%rbp),%rcx
mov    -0x98(%rbp),%r8
mov    -0xa0(%rbp),%r9
mov    -0x30(%rbp),%r10
mov    -0x6c(%rbp),%eax
mov    %r10,(%rsp)
mov    %eax,0x8(%rsp)
mov    $0x0,%al
call   10a0 <DiagOfTriXTri@plt>
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jge    1806 <SBL+0x636>
movsd  -0x40(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x68(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    17cd <SBL+0x5fd>
jmp    180b <SBL+0x63b>
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jge    188e <SBL+0x6be>
movsd  -0x48(%rbp),%xmm0
addsd  %xmm0,%xmm0
movsd  0x7d1(%rip),%xmm1
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x30(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  -0x50(%rbp),%xmm1
addsd  %xmm1,%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1812 <SBL+0x642>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jge    1942 <SBL+0x772>
mov    -0xd0(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x68(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
xorps  %xmm0,%xmm0
ucomisd -0x90(%rbp),%xmm0
ff
jbe    1909 <SBL+0x739>
movsd  -0x90(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
ucomisd -0x88(%rbp),%xmm0
ff
jbe    192f <SBL+0x75f>
movsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
jmp    1934 <SBL+0x764>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    18a0 <SBL+0x6d0>
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0x60(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1981 <SBL+0x7b1>
cmpl   $0x0,0x20(%rbp)
jle    197c <SBL+0x7ac>
mov    -0x64(%rbp),%esi
movsd  -0x60(%rbp),%xmm0
mov    -0x6c(%rbp),%edx
lea    0x69b(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
jmp    1bf2 <SBL+0xa22>
mov    -0x20(%rbp),%rdi
mov    -0x6c(%rbp),%esi
movsd  -0x58(%rbp),%xmm0
mov    -0xe8(%rbp),%rdx
mov    $0x1,%al
call   10f0 <findminus@plt>
mov    %eax,-0x74(%rbp)
cmpl   $0x0,-0x74(%rbp)
jne    1a02 <SBL+0x832>
movl   $0x0,-0x6c(%rbp)
mov    -0x28(%rbp),%rax
movsd  0x64d(%rip),%xmm0
movsd  %xmm0,(%rax)
mov    -0x18(%rbp),%rax
movl   $0xffffffff,(%rax)
mov    -0x30(%rbp),%rax
movsd  0x633(%rip),%xmm0
movsd  %xmm0,(%rax)
mov    -0x20(%rbp),%rax
movsd  0x623(%rip),%xmm0
movsd  %xmm0,(%rax)
mov    -0x64(%rbp),%esi
mov    -0x6c(%rbp),%edx
lea    0x660(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    1bf2 <SBL+0xa22>
mov    -0x74(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jge    1bdf <SBL+0xa0f>
mov    -0x74(%rbp),%eax
mov    %eax,-0x6c(%rbp)
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x74(%rbp),%eax
jge    1a56 <SBL+0x886>
mov    -0x18(%rbp),%rax
mov    -0xe8(%rbp),%rcx
movslq -0x68(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x18(%rbp),%rax
movslq -0x68(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1a1b <SBL+0x84b>
mov    -0x18(%rbp),%rdi
mov    -0x34(%rbp),%esi
mov    -0x6c(%rbp),%edx
mov    -0x98(%rbp),%rcx
mov    -0xa0(%rbp),%r8
mov    $0x0,%al
call   10c0 <ComputeHs@plt>
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jge    1abb <SBL+0x8eb>
mov    -0x20(%rbp),%rax
mov    -0xe8(%rbp),%rcx
movslq -0x68(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1a7c <SBL+0x8ac>
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jge    1b04 <SBL+0x934>
mov    -0xb0(%rbp),%rax
mov    -0x18(%rbp),%rcx
movslq -0x68(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xb8(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1ac2 <SBL+0x8f2>
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jge    1b38 <SBL+0x968>
mov    -0xa8(%rbp),%rax
movslq -0x68(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1b0b <SBL+0x93b>
mov    -0x98(%rbp),%rdi
mov    -0xa0(%rbp),%rsi
mov    -0xb8(%rbp),%rdx
mov    -0x6c(%rbp),%ecx
mov    -0xa8(%rbp),%r8
mov    $0x0,%al
call   1060 <TriSymGaxpy@plt>
mov    -0xa8(%rbp),%rax
mov    %rax,-0x80(%rbp)
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jge    1bda <SBL+0xa0a>
mov    -0x28(%rbp),%rax
mov    -0xe8(%rbp),%rcx
movslq -0x68(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xd0(%rbp),%rax
mov    -0xe8(%rbp),%rcx
movslq -0x68(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xd0(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1b70 <SBL+0x9a0>
jmp    1bdf <SBL+0xa0f>
jmp    1be4 <SBL+0xa14>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1574 <SBL+0x3a4>
cmpl   $0x0,0x20(%rbp)
jle    1c29 <SBL+0xa59>
mov    -0x68(%rbp),%eax
cmp    0x18(%rbp),%eax
jl     1c24 <SBL+0xa54>
mov    -0x64(%rbp),%esi
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x6c(%rbp),%edx
lea    0x479(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
jmp    1c29 <SBL+0xa59>
cmpl   $0x0,-0x6c(%rbp)
je     1d13 <SBL+0xb43>
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jge    1c7c <SBL+0xaac>
mov    -0xb0(%rbp),%rax
mov    -0x18(%rbp),%rcx
movslq -0x68(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xb8(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1c3a <SBL+0xa6a>
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jge    1cba <SBL+0xaea>
mov    -0x98(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1c83 <SBL+0xab3>
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jge    1ceb <SBL+0xb1b>
mov    -0x28(%rbp),%rax
movslq -0x68(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1cc1 <SBL+0xaf1>
mov    -0x98(%rbp),%rdi
mov    -0xa0(%rbp),%rsi
mov    -0xb8(%rbp),%rdx
mov    -0x6c(%rbp),%ecx
mov    -0x28(%rbp),%r8
mov    $0x0,%al
call   1060 <TriSymGaxpy@plt>
jmp    1d26 <SBL+0xb56>
mov    -0x98(%rbp),%rax
movsd  0x2e6(%rip),%xmm0
movsd  %xmm0,(%rax)
mov    -0xf8(%rbp),%rdi
call   1030 <free@plt>
mov    -0x98(%rbp),%rdi
call   1030 <free@plt>
mov    -0xa0(%rbp),%rdi
call   1030 <free@plt>
mov    -0xa8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xb0(%rbp),%rdi
call   1030 <free@plt>
mov    -0xb8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xc0(%rbp),%rdi
call   1030 <free@plt>
mov    -0xc8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xd0(%rbp),%rdi
call   1030 <free@plt>
mov    -0xd8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xe0(%rbp),%rdi
call   1030 <free@plt>
mov    -0xe8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xf0(%rbp),%rdi
call   1030 <free@plt>
mov    -0x6c(%rbp),%ecx
mov    0x10(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x64(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x110,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<SBL>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x138,%rsp
movsd  %xmm4,0xc8(%rsp)
movsd  %xmm3,0x118(%rsp)
movapd %xmm0,0xb0(%rsp)
mov    %r8,%r13
mov    0x170(%rsp),%r8
movslq (%r8),%rbp
mov    %rbp,%rax
mov    %rbp,(%rsp)
test   %rbp,%rbp
je     14c9 <SBL+0x2d9>
mov    %r9d,%ebx
mov    %rdi,0x8(%rsp)
movapd %xmm1,0xd0(%rsp)
mov    %rdx,0x58(%rsp)
movapd %xmm2,0xe0(%rsp)
mov    %rsi,0x30(%rsp)
mov    %rcx,0x10(%rsp)
lea    -0x1(%rbx),%r15d
mov    (%rsp),%r14
mov    %r14d,%eax
mov    %rax,0x50(%rsp)
movslq %r9d,%rbp
mov    $0x8,%esi
mov    %rbp,%rdi
call   1090 <calloc@plt>
mov    %rbx,0x90(%rsp)
mov    %rax,0x48(%rsp)
mov    $0x8,%esi
mov    %rbp,%rdi
call   1090 <calloc@plt>
mov    %rax,0x18(%rsp)
mov    %r15d,0x70(%rsp)
movslq %r15d,%r15
mov    $0x8,%esi
mov    %r15,%rdi
call   1090 <calloc@plt>
mov    %rax,0x88(%rsp)
mov    $0x8,%esi
mov    %r15,%rdi
call   1090 <calloc@plt>
mov    %rax,0x80(%rsp)
lea    0x0(,%rbp,4),%eax
movslq %eax,%rdi
mov    $0x8,%esi
call   1090 <calloc@plt>
mov    %rax,0xa0(%rsp)
lea    -0x2(%rbp),%eax
movslq %eax,%rbx
mov    $0x8,%esi
mov    %rbx,%rdi
call   1090 <calloc@plt>
mov    %rax,0xa8(%rsp)
mov    $0x8,%esi
mov    %rbx,%rdi
call   1090 <calloc@plt>
mov    %rax,0xc0(%rsp)
mov    $0x8,%esi
mov    %r15,%rdi
call   1090 <calloc@plt>
mov    %rax,0x20(%rsp)
mov    $0x8,%esi
mov    %rbx,%rdi
call   1090 <calloc@plt>
mov    %rax,0x28(%rsp)
mov    $0x8,%esi
mov    %r14,%rdi
call   1090 <calloc@plt>
mov    %rax,%r12
mov    $0x4,%esi
mov    %r14,%rdi
call   1090 <calloc@plt>
mov    %rax,0x98(%rsp)
mov    $0x8,%esi
mov    %r15,%rdi
mov    0x48(%rsp),%r15
mov    0x90(%rsp),%rbx
call   1090 <calloc@plt>
mov    %rax,0x40(%rsp)
mov    $0x8,%esi
mov    %r14,%rdi
call   1090 <calloc@plt>
mov    %rax,0x60(%rsp)
test   %ebp,%ebp
jle    13b1 <SBL+0x1c1>
mov    %ebx,%edx
shl    $0x3,%rdx
mov    %r15,%rdi
mov    0x8(%rsp),%rsi
call   10e0 <memcpy@plt>
movl   $0x0,0x8(%rsp)
mov    0x20(%rsp),%rbp
mov    %rbp,%rdi
mov    0x28(%rsp),%rsi
mov    %ebx,%edx
xor    %eax,%eax
call   1040 <ComputeH@plt>
mov    %ebx,%edi
mov    %r15,%rsi
xor    %eax,%eax
call   1100 <ComputeFdualXb@plt>
cmpl   $0x0,(%rsp)
mov    0x18(%rsp),%rbx
mov    0x60(%rsp),%r14
jle    142a <SBL+0x23a>
mov    0x50(%rsp),%rax
lea    0x0(,%rax,8),%r15
mov    %r14,%rdi
mov    0x48(%rsp),%rsi
mov    %r15,%rdx
call   10e0 <memcpy@plt>
mov    %rbx,%rdi
mov    0x20(%rsp),%rsi
mov    %r15,%rdx
mov    0x20(%rsp),%rbp
mov    0x48(%rsp),%r15
call   10e0 <memcpy@plt>
mov    (%rsp),%rax
mov    %eax,0x8(%rsp)
mov    %rbx,%rdi
mov    0x28(%rsp),%rbx
mov    %rbx,%rsi
mov    %rbx,%rdx
mov    %r14,%rcx
mov    0x40(%rsp),%r8
mov    0x70(%rsp),%r14d
mov    %r14d,%r9d
xor    %eax,%eax
call   10f0 <TrisolveREG@plt>
mov    0x178(%rsp),%eax
mov    %r15,0x68(%rsp)
cmp    %r14d,(%rsp)
mov    %r12,0x38(%rsp)
jge    15da <SBL+0x3ea>
movl   $0x0,0x8(%rsp)
mov    0x30(%rsp),%rdi
mov    0x90(%rsp),%rsi
mov    %rbp,%rcx
mov    (%rsp),%rbp
mov    %ebp,%edx
mov    %rcx,%r14
mov    %rbx,%r8
xor    %eax,%eax
call   10d0 <ComputeHs@plt>
test   %ebp,%ebp
mov    0x18(%rsp),%rdx
jle    15b2 <SBL+0x3c2>
mov    0x50(%rsp),%r9
lea    -0x1(%r9),%rcx
mov    %r9d,%r8d
and    $0x3,%r8d
cmp    $0x3,%rcx
jae    14e9 <SBL+0x2f9>
xor    %ecx,%ecx
mov    0x30(%rsp),%rbx
mov    0x40(%rsp),%rax
jmp    1547 <SBL+0x357>
movabs $0xbff0000000000000,%rax
mov    %rax,(%rcx)
movl   $0x0,(%r8)
mov    %rax,0x0(%r13)
xor    %r14d,%r14d
jmp    247c <SBL+0x128c>
mov    %r9d,%edi
and    $0xfffffffc,%edi
xor    %ecx,%ecx
mov    0x30(%rsp),%rbx
mov    0x40(%rsp),%rax
nopl   0x0(%rax,%rax,1)
movslq (%rbx,%rcx,4),%rsi
movsd  (%rax,%rsi,8),%xmm0
movsd  %xmm0,(%rdx,%rcx,8)
movslq 0x4(%rbx,%rcx,4),%rsi
movsd  (%rax,%rsi,8),%xmm0
movsd  %xmm0,0x8(%rdx,%rcx,8)
movslq 0x8(%rbx,%rcx,4),%rsi
movsd  (%rax,%rsi,8),%xmm0
movsd  %xmm0,0x10(%rdx,%rcx,8)
movslq 0xc(%rbx,%rcx,4),%rsi
movsd  (%rax,%rsi,8),%xmm0
movsd  %xmm0,0x18(%rdx,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rdi
jne    1500 <SBL+0x310>
test   %r8,%r8
je     1578 <SBL+0x388>
lea    (%rdx,%rcx,8),%rbp
lea    (%rbx,%rcx,4),%rcx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
movslq (%rcx,%rsi,4),%rdi
movsd  (%rax,%rdi,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rsi,8)
add    $0x1,%rsi
cmp    %rsi,%r8
jne    1560 <SBL+0x370>
cmpl   $0x0,(%rsp)
jle    15a0 <SBL+0x3b0>
shl    $0x3,%r9
mov    0x60(%rsp),%rdi
xor    %esi,%esi
mov    %r9,%rdx
call   1070 <memset@plt>
mov    0x18(%rsp),%rdx
mov    (%rsp),%rax
mov    %eax,0x8(%rsp)
jmp    15a8 <SBL+0x3b8>
movl   $0x0,0x8(%rsp)
mov    0x38(%rsp),%r12
mov    0x28(%rsp),%rbx
mov    %r14,%rbp
mov    %r14,%rdi
mov    %rbx,%rsi
mov    (%rsp),%rcx
mov    0x60(%rsp),%r14
mov    %r14,%r8
xor    %eax,%eax
call   1060 <TriSymGaxpy@plt>
mov    %r14,0x68(%rsp)
mov    0x178(%rsp),%eax
mov    0x180(%rsp),%ecx
test   %eax,%eax
jle    2175 <SBL+0xf85>
movapd 0xd0(%rsp),%xmm2
addsd  %xmm2,%xmm2
addsd  0x1a02(%rip),%xmm2
movapd 0xb0(%rsp),%xmm3
unpcklpd %xmm3,%xmm3
movapd 0xe0(%rsp),%xmm1
movapd %xmm1,%xmm0
unpcklpd %xmm1,%xmm0
movapd %xmm0,0x100(%rsp)
movapd %xmm2,%xmm4
unpcklpd %xmm2,%xmm4
addsd  %xmm1,%xmm1
movl   $0x0,0x50(%rsp)
mov    0x10(%rsp),%r8
mov    0x98(%rsp),%r14
movapd %xmm1,0xe0(%rsp)
movapd %xmm2,0xd0(%rsp)
movapd %xmm3,0x120(%rsp)
movapd %xmm4,0xf0(%rsp)
jmp    16f3 <SBL+0x503>
mov    0x30(%rsp),%rdi
mov    0x90(%rsp),%rsi
mov    (%rsp),%rdx
mov    0x20(%rsp),%rcx
mov    %rbx,%r8
xor    %eax,%eax
call   10d0 <ComputeHs@plt>
mov    0x18(%rsp),%rbp
movl   $0x0,0x8(%rsp)
mov    0x20(%rsp),%rdi
mov    0x28(%rsp),%rbx
mov    %rbx,%rsi
mov    %rbp,%rdx
mov    (%rsp),%rcx
mov    0x60(%rsp),%rbp
mov    %rbp,%r8
xor    %eax,%eax
call   1060 <TriSymGaxpy@plt>
mov    %rbp,0x68(%rsp)
mov    0x10(%rsp),%r8
mov    0x38(%rsp),%r12
movapd 0x70(%rsp),%xmm0
mov    0x50(%rsp),%eax
add    $0x1,%eax
mov    %eax,0x50(%rsp)
mov    0x178(%rsp),%ecx
cmp    %ecx,%eax
mov    0x20(%rsp),%rbp
je     21f0 <SBL+0x1000>
mov    (%rsp),%rax
mov    %eax,%r15d
test   %eax,%eax
jle    17e0 <SBL+0x5f0>
lea    0x0(,%r15,8),%rdx
mov    %r12,%rdi
mov    %r8,%rsi
mov    %rbp,%r12
call   10e0 <memcpy@plt>
sub    $0x8,%rsp
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    0x8(%rsp),%rbx
mov    %ebx,%edx
mov    0x60(%rsp),%rcx
movaps 0xb8(%rsp),%xmm0
mov    0x20(%rsp),%rbp
mov    %rbp,%r8
mov    0x90(%rsp),%r9
mov    $0x1,%al
push   0x88(%rsp)
call   1080 <ComputeT@plt>
add    $0x10,%rsp
cmp    $0x1,%ebx
jne    1940 <SBL+0x750>
mov    0x68(%rsp),%rax
movsd  (%rax),%xmm0
movsd  0x0(%rbp),%xmm1
divsd  %xmm1,%xmm0
mov    0x10(%rsp),%r8
movsd  %xmm0,(%r8)
movsd  0x187b(%rip),%xmm0
divsd  %xmm1,%xmm0
mulsd  (%r12),%xmm0
mulsd  0xb0(%rsp),%xmm0
movsd  %xmm0,0x0(%r13)
mov    %rbp,%rdx
mov    0x38(%rsp),%r12
mov    0x28(%rsp),%rbx
movapd 0xe0(%rsp),%xmm4
mov    0x58(%rsp),%rdi
movapd 0xd0(%rsp),%xmm5
movapd 0x100(%rsp),%xmm3
movapd 0xf0(%rsp),%xmm6
jmp    1b25 <SBL+0x935>
nopl   0x0(%rax)
mov    %r15,0x70(%rsp)
sub    $0x8,%rsp
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    0x8(%rsp),%rdx
mov    0x60(%rsp),%rcx
movapd 0xb8(%rsp),%xmm0
mov    0x20(%rsp),%rbx
mov    %rbx,%r8
mov    0x90(%rsp),%r9
mov    $0x1,%al
push   0x88(%rsp)
call   1080 <ComputeT@plt>
mov    %rbx,%r9
add    $0x10,%rsp
mov    0xa0(%rsp),%rdi
movl   $0x0,0x8(%rsp)
mov    $0x4,%esi
mov    (%rsp),%r12
mov    %r12d,%edx
mov    0x10(%rsp),%rcx
mov    0xa8(%rsp),%r8
mov    %r9,%rbx
mov    0xc0(%rsp),%r15
mov    %r15,%r9
xor    %eax,%eax
call   10c0 <TriSolveINV@plt>
mov    %rbx,%rdi
mov    0x88(%rsp),%rbp
mov    %rbp,%rsi
mov    %rbp,%rdx
mov    %rbx,%rcx
mov    0x80(%rsp),%r14
mov    %r14,%r8
mov    %r12d,%r9d
xor    %eax,%eax
push   %r15
push   0xb0(%rsp)
call   10a0 <tridiagofinverse@plt>
add    $0x10,%rsp
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    %r14,%rdx
mov    0x28(%rsp),%rbx
mov    %rbx,%rcx
mov    0x20(%rsp),%r8
mov    %rbx,%r9
xor    %eax,%eax
push   %r12
push   %r13
call   10b0 <DiagOfTriXTri@plt>
add    $0x10,%rsp
xorpd  %xmm7,%xmm7
mov    %r12,(%rsp)
test   %r12d,%r12d
jle    19f0 <SBL+0x800>
cmpl   $0x4,(%rsp)
mov    0x98(%rsp),%r14
mov    0x38(%rsp),%r12
movapd 0xe0(%rsp),%xmm4
mov    0x58(%rsp),%rdi
movapd 0xd0(%rsp),%xmm5
movapd 0xb0(%rsp),%xmm1
movapd 0x120(%rsp),%xmm6
movapd 0x100(%rsp),%xmm3
jae    1a20 <SBL+0x830>
xor    %eax,%eax
mov    0x10(%rsp),%r8
mov    0x18(%rsp),%rdx
movapd 0xf0(%rsp),%xmm6
mov    0x70(%rsp),%r15
jmp    1b00 <SBL+0x910>
nopl   0x0(%rax)
mov    (%rsp),%rax
lea    -0x1(%rax),%r8d
shl    $0x2,%r8
mov    %r15,0x70(%rsp)
lea    0x0(,%r15,4),%r10
xor    %edx,%edx
xor    %esi,%esi
mov    0xa0(%rsp),%rdi
mov    %rbp,%r9
mov    0x68(%rsp),%rcx
jmp    19d8 <SBL+0x7e8>
nop
mov    0x80(%rsp),%rax
movsd  (%rax,%rdx,2),%xmm0
lea    0x0(,%rsi,4),%eax
movslq %edx,%rbx
movsd  %xmm0,(%rdi,%rbx,8)
mov    0x88(%rsp),%rbp
movsd  0x0(%rbp,%rdx,2),%xmm0
add    $0x2,%ebx
movslq %ebx,%rbx
movsd  %xmm0,(%rdi,%rbx,8)
movsd  (%r9,%rdx,2),%xmm0
mov    %eax,%ebp
or     $0x1,%ebp
movslq %ebp,%rbp
movsd  %xmm0,(%rdi,%rbp,8)
movsd  (%rcx,%rdx,2),%xmm0
or     $0x3,%eax
cltq
movsd  %xmm0,(%rdi,%rax,8)
add    $0x1,%rsi
add    $0x4,%rdx
cmp    %rdx,%r10
je     182f <SBL+0x63f>
cmp    %rdx,%r8
jne    1970 <SBL+0x780>
mov    %edx,%eax
jmp    19a5 <SBL+0x7b5>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x10(%rsp),%r8
mov    0x18(%rsp),%rdx
mov    0x98(%rsp),%r14
mov    0x38(%rsp),%r12
mov    0x58(%rsp),%rdi
jmp    1e00 <SBL+0xc10>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rbx,%r9
mov    0x70(%rsp),%r15
mov    %r15d,%eax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rdx
mov    %rdx,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
test   %rdx,%rdx
je     1aa4 <SBL+0x8b4>
mov    %rcx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movupd 0x0(%r13,%rbx,8),%xmm0
movupd 0x10(%r13,%rbx,8),%xmm1
movupd 0x20(%r13,%rbx,8),%xmm2
movupd 0x30(%r13,%rbx,8),%xmm3
mulpd  %xmm6,%xmm0
mulpd  %xmm6,%xmm1
movupd %xmm0,0x0(%r13,%rbx,8)
movupd %xmm1,0x10(%r13,%rbx,8)
mulpd  %xmm6,%xmm2
mulpd  %xmm6,%xmm3
movupd %xmm2,0x20(%r13,%rbx,8)
movupd %xmm3,0x30(%r13,%rbx,8)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%rsi
jne    1a50 <SBL+0x860>
jmp    1aa6 <SBL+0x8b6>
xor    %ebx,%ebx
test   $0x1,%cl
mov    0x10(%rsp),%r8
mov    0x18(%rsp),%rdx
je     1ad9 <SBL+0x8e9>
movupd 0x0(%r13,%rbx,8),%xmm0
movupd 0x10(%r13,%rbx,8),%xmm1
mulpd  %xmm6,%xmm0
mulpd  %xmm6,%xmm1
movupd %xmm0,0x0(%r13,%rbx,8)
movupd %xmm1,0x10(%r13,%rbx,8)
cmp    %r15,%rax
movapd 0xb0(%rsp),%xmm1
movapd 0x100(%rsp),%xmm3
movapd 0xf0(%rsp),%xmm6
mov    %r9,%rbx
je     1b1b <SBL+0x92b>
nopl   0x0(%rax)
movsd  0x0(%r13,%rax,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x0(%r13,%rax,8)
add    $0x1,%rax
cmp    %rax,%r15
jne    1b00 <SBL+0x910>
cmpl   $0x0,(%rsp)
jle    1e00 <SBL+0xc10>
cmpl   $0x2,(%rsp)
jae    1b40 <SBL+0x950>
xor    %eax,%eax
jmp    1c60 <SBL+0xa70>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    (%r8,%r15,8),%rax
cmp    %rdi,%rax
seta   %al
lea    (%rdi,%r15,8),%rsi
cmp    %r8,%rsi
seta   %bl
lea    0x0(,%r15,8),%rcx
add    %r13,%rcx
cmp    %rdi,%rcx
seta   %cl
cmp    %r13,%rsi
seta   %sil
test   %bl,%al
jne    1c50 <SBL+0xa60>
mov    $0x0,%eax
and    %sil,%cl
mov    0x28(%rsp),%rbx
jne    1c60 <SBL+0xa70>
mov    %rbx,%r9
mov    %r15d,%eax
and    $0xfffffffe,%eax
lea    -0x2(%rax),%rcx
mov    %rcx,%rbx
shr    %rbx
add    $0x1,%rbx
test   %rcx,%rcx
je     2148 <SBL+0xf58>
mov    %rbx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
movupd (%r8,%rcx,8),%xmm0
movupd 0x0(%r13,%rcx,8),%xmm1
mulpd  %xmm0,%xmm0
addpd  %xmm1,%xmm0
movapd %xmm3,%xmm1
addpd  %xmm3,%xmm1
addpd  %xmm1,%xmm0
movapd %xmm6,%xmm2
divpd  %xmm0,%xmm2
movupd %xmm2,(%rdi,%rcx,8)
movupd 0x10(%r8,%rcx,8),%xmm0
movupd 0x10(%r13,%rcx,8),%xmm2
mulpd  %xmm0,%xmm0
addpd  %xmm2,%xmm0
addpd  %xmm1,%xmm0
movapd %xmm6,%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,0x10(%rdi,%rcx,8)
add    $0x4,%rcx
add    $0xfffffffffffffffe,%rsi
jne    1bb0 <SBL+0x9c0>
test   $0x1,%bl
je     1c43 <SBL+0xa53>
movupd (%r8,%rcx,8),%xmm0
movupd 0x0(%r13,%rcx,8),%xmm1
mulpd  %xmm0,%xmm0
addpd  %xmm1,%xmm0
movapd %xmm3,%xmm1
addpd  %xmm3,%xmm1
addpd  %xmm0,%xmm1
movapd %xmm6,%xmm0
divpd  %xmm1,%xmm0
movupd %xmm0,(%rdi,%rcx,8)
cmp    %r15,%rax
mov    %r9,%rbx
jne    1c60 <SBL+0xa70>
jmp    1cef <SBL+0xaff>
xor    %eax,%eax
mov    0x28(%rsp),%rbx
nopw   0x0(%rax,%rax,1)
mov    %rax,%rcx
test   $0x1,%r15b
je     1c92 <SBL+0xaa2>
movsd  (%r8,%rax,8),%xmm0
mulsd  %xmm0,%xmm0
addsd  0x0(%r13,%rax,8),%xmm0
addsd  %xmm4,%xmm0
movapd %xmm5,%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%rdi,%rax,8)
mov    %rax,%rcx
or     $0x1,%rcx
not    %rax
add    %r15,%rax
je     1cef <SBL+0xaff>
nopw   0x0(%rax,%rax,1)
movsd  (%r8,%rcx,8),%xmm0
mulsd  %xmm0,%xmm0
addsd  0x0(%r13,%rcx,8),%xmm0
addsd  %xmm4,%xmm0
movapd %xmm5,%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%rdi,%rcx,8)
movsd  0x8(%r8,%rcx,8),%xmm0
mulsd  %xmm0,%xmm0
addsd  0x8(%r13,%rcx,8),%xmm0
addsd  %xmm4,%xmm0
movapd %xmm5,%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rdi,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%r15
jne    1ca0 <SBL+0xab0>
cmpl   $0x0,(%rsp)
jle    1d10 <SBL+0xb20>
cmpl   $0x1,(%rsp)
jne    1d21 <SBL+0xb31>
xorpd  %xmm7,%xmm7
xor    %eax,%eax
jmp    1da5 <SBL+0xbb5>
cs nopw 0x0(%rax,%rax,1)
movl   $0x0,0x8(%rsp)
xorpd  %xmm7,%xmm7
jmp    1e00 <SBL+0xc10>
mov    %r15d,%ecx
and    $0xfffffffe,%ecx
xorpd  %xmm7,%xmm7
xor    %eax,%eax
xorpd  %xmm4,%xmm4
movapd 0x12d7(%rip),%xmm5
nopl   0x0(%rax)
movsd  (%r12,%rax,8),%xmm0
movsd  0x8(%r12,%rax,8),%xmm1
subsd  (%r8,%rax,8),%xmm0
movapd %xmm0,%xmm2
xorpd  %xmm5,%xmm2
movapd %xmm0,%xmm3
cmpltsd %xmm4,%xmm3
andpd  %xmm3,%xmm2
andnpd %xmm0,%xmm3
orpd   %xmm2,%xmm3
maxsd  %xmm7,%xmm3
subsd  0x8(%r8,%rax,8),%xmm1
movapd %xmm1,%xmm0
xorpd  %xmm5,%xmm0
movapd %xmm1,%xmm7
cmpltsd %xmm4,%xmm7
andpd  %xmm7,%xmm0
andnpd %xmm1,%xmm7
orpd   %xmm0,%xmm7
maxsd  %xmm3,%xmm7
add    $0x2,%rax
cmp    %rax,%rcx
jne    1d40 <SBL+0xb50>
xorpd  %xmm3,%xmm3
mov    (%rsp),%rcx
mov    %ecx,0x8(%rsp)
test   $0x1,%r15b
je     1e00 <SBL+0xc10>
movsd  (%r12,%rax,8),%xmm0
subsd  (%r8,%rax,8),%xmm0
movapd %xmm0,%xmm1
xorpd  0x1241(%rip),%xmm1
movapd %xmm0,%xmm2
cmpltsd %xmm3,%xmm2
andpd  %xmm2,%xmm1
andnpd %xmm0,%xmm2
orpd   %xmm1,%xmm2
maxsd  %xmm7,%xmm2
movapd %xmm2,%xmm7
mov    (%rsp),%rax
mov    %eax,0x8(%rsp)
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  0xc8(%rsp),%xmm0
ucomisd %xmm7,%xmm0
movapd %xmm7,0x70(%rsp)
ja     218f <SBL+0xf9f>
mov    (%rsp),%rsi
movsd  0x118(%rsp),%xmm0
mov    %r14,%rdx
mov    $0x1,%al
call   1110 <findminus@plt>
test   %eax,%eax
je     220a <SBL+0x101a>
mov    %eax,%r15d
cmp    (%rsp),%eax
mov    0x10(%rsp),%r8
movapd 0x70(%rsp),%xmm0
jge    16d4 <SBL+0x4e4>
mov    %r15d,%eax
mov    %rax,(%rsp)
test   %r15d,%r15d
jle    166f <SBL+0x47f>
mov    %r15d,%r12d
lea    -0x1(%r12),%rax
mov    %r12d,%ebx
and    $0x3,%ebx
mov    %rax,0x8(%rsp)
cmp    $0x3,%rax
mov    0x30(%rsp),%rdi
jae    1e81 <SBL+0xc91>
xor    %eax,%eax
jmp    1ec7 <SBL+0xcd7>
mov    %r12d,%ecx
and    $0xfffffffc,%ecx
xor    %eax,%eax
nopl   0x0(%rax)
movslq (%r14,%rax,4),%rdx
mov    (%rdi,%rdx,4),%edx
mov    %edx,(%rdi,%rax,4)
movslq 0x4(%r14,%rax,4),%rdx
mov    (%rdi,%rdx,4),%edx
mov    %edx,0x4(%rdi,%rax,4)
movslq 0x8(%r14,%rax,4),%rdx
mov    (%rdi,%rdx,4),%edx
mov    %edx,0x8(%rdi,%rax,4)
movslq 0xc(%r14,%rax,4),%rdx
mov    (%rdi,%rdx,4),%edx
mov    %edx,0xc(%rdi,%rax,4)
add    $0x4,%rax
cmp    %rax,%rcx
jne    1e90 <SBL+0xca0>
test   %rbx,%rbx
je     1ef3 <SBL+0xd03>
lea    (%rdi,%rax,4),%rcx
lea    (%r14,%rax,4),%rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
movslq (%rax,%rdx,4),%rsi
mov    (%rdi,%rsi,4),%esi
mov    %esi,(%rcx,%rdx,4)
add    $0x1,%rdx
cmp    %rdx,%rbx
jne    1ee0 <SBL+0xcf0>
mov    0x90(%rsp),%rsi
mov    (%rsp),%rdx
mov    0x20(%rsp),%rcx
mov    0x28(%rsp),%r8
xor    %eax,%eax
call   10d0 <ComputeHs@plt>
test   %r15d,%r15d
mov    0x18(%rsp),%rbp
jle    1694 <SBL+0x4a4>
cmpq   $0x3,0x8(%rsp)
jae    1f2f <SBL+0xd3f>
xor    %eax,%eax
mov    0x58(%rsp),%rdi
jmp    1f87 <SBL+0xd97>
mov    %r12d,%ecx
and    $0xfffffffc,%ecx
xor    %eax,%eax
mov    0x58(%rsp),%rdi
nopl   0x0(%rax)
movslq (%r14,%rax,4),%rdx
movsd  (%rdi,%rdx,8),%xmm0
movsd  %xmm0,(%rdi,%rax,8)
movslq 0x4(%r14,%rax,4),%rdx
movsd  (%rdi,%rdx,8),%xmm0
movsd  %xmm0,0x8(%rdi,%rax,8)
movslq 0x8(%r14,%rax,4),%rdx
movsd  (%rdi,%rdx,8),%xmm0
movsd  %xmm0,0x10(%rdi,%rax,8)
movslq 0xc(%r14,%rax,4),%rdx
movsd  (%rdi,%rdx,8),%xmm0
movsd  %xmm0,0x18(%rdi,%rax,8)
add    $0x4,%rax
cmp    %rax,%rcx
jne    1f40 <SBL+0xd50>
test   $0x3,%r12b
je     1fb7 <SBL+0xdc7>
lea    (%rdi,%rax,8),%rcx
lea    (%r14,%rax,4),%rax
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movslq (%rax,%rdx,4),%rsi
movsd  (%rdi,%rsi,8),%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%rbx
jne    1fa0 <SBL+0xdb0>
test   %r15d,%r15d
jle    1694 <SBL+0x4a4>
cmpq   $0x3,0x8(%rsp)
jae    1fd6 <SBL+0xde6>
xor    %eax,%eax
mov    0x30(%rsp),%rsi
mov    0x40(%rsp),%rdi
jmp    2038 <SBL+0xe48>
mov    %r12d,%ecx
and    $0xfffffffc,%ecx
xor    %eax,%eax
mov    0x30(%rsp),%rsi
mov    0x40(%rsp),%rdi
nopl   0x0(%rax,%rax,1)
movslq (%rsi,%rax,4),%rdx
movsd  (%rdi,%rdx,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rax,8)
movslq 0x4(%rsi,%rax,4),%rdx
movsd  (%rdi,%rdx,8),%xmm0
movsd  %xmm0,0x8(%rbp,%rax,8)
movslq 0x8(%rsi,%rax,4),%rdx
movsd  (%rdi,%rdx,8),%xmm0
movsd  %xmm0,0x10(%rbp,%rax,8)
movslq 0xc(%rsi,%rax,4),%rdx
movsd  (%rdi,%rdx,8),%xmm0
movsd  %xmm0,0x18(%rbp,%rax,8)
add    $0x4,%rax
cmp    %rax,%rcx
jne    1ff0 <SBL+0xe00>
test   $0x3,%r12b
je     2067 <SBL+0xe77>
lea    0x0(,%rax,8),%rcx
add    %rbp,%rcx
lea    (%rsi,%rax,4),%rax
xor    %edx,%edx
nop
movslq (%rax,%rdx,4),%rsi
movsd  (%rdi,%rsi,8),%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%rbx
jne    2050 <SBL+0xe60>
test   %r15d,%r15d
jle    1694 <SBL+0x4a4>
mov    %r12,%rdx
shl    $0x3,%rdx
mov    0x60(%rsp),%r15
mov    %r15,%rdi
xor    %esi,%esi
call   1070 <memset@plt>
mov    0x20(%rsp),%rdi
mov    0x28(%rsp),%rbx
mov    %rbx,%rsi
mov    %rbp,%rdx
mov    (%rsp),%rcx
mov    %r15,%r8
xor    %eax,%eax
call   1060 <TriSymGaxpy@plt>
cmpq   $0x0,0x8(%rsp)
je     2158 <SBL+0xf68>
mov    %r12,%rsi
mov    %r12d,%ecx
and    $0xfffffffe,%ecx
xor    %eax,%eax
mov    0x10(%rsp),%r8
mov    0x38(%rsp),%r12
movapd 0x70(%rsp),%xmm0
nopl   0x0(%rax,%rax,1)
movslq (%r14,%rax,4),%rdx
movsd  (%r8,%rdx,8),%xmm5
movsd  %xmm5,(%r8,%rax,8)
movsd  (%r12,%rdx,8),%xmm5
movsd  %xmm5,(%r12,%rax,8)
movslq 0x4(%r14,%rax,4),%rdx
movsd  (%r8,%rdx,8),%xmm5
movsd  %xmm5,0x8(%r8,%rax,8)
movsd  (%r12,%rdx,8),%xmm5
movsd  %xmm5,0x8(%r12,%rax,8)
add    $0x2,%rax
cmp    %rax,%rcx
jne    20d0 <SBL+0xee0>
test   $0x1,%sil
je     2136 <SBL+0xf46>
movslq (%r14,%rax,4),%rcx
movsd  (%r8,%rcx,8),%xmm5
movsd  %xmm5,(%r8,%rax,8)
movsd  (%r12,%rcx,8),%xmm5
movsd  %xmm5,(%r12,%rax,8)
mov    %r15,0x68(%rsp)
mov    (%rsp),%rax
mov    %eax,0x8(%rsp)
jmp    16d4 <SBL+0x4e4>
xor    %ecx,%ecx
test   $0x1,%bl
jne    1c15 <SBL+0xa25>
jmp    1c43 <SBL+0xa53>
mov    %r12,%rsi
xor    %eax,%eax
mov    0x10(%rsp),%r8
mov    0x38(%rsp),%r12
movapd 0x70(%rsp),%xmm0
test   $0x1,%sil
jne    211a <SBL+0xf2a>
jmp    2136 <SBL+0xf46>
mov    0x10(%rsp),%r8
xor    %r14d,%r14d
mov    0x48(%rsp),%r15
test   %ecx,%ecx
jg     2276 <SBL+0x1086>
jmp    2296 <SBL+0x10a6>
cmpl   $0x0,0x180(%rsp)
mov    0x48(%rsp),%r15
jle    23b5 <SBL+0x11c5>
lea    0xe77(%rip),%rdi
mov    0x50(%rsp),%r14d
mov    %r14d,%esi
movsd  0xc8(%rsp),%xmm0
mov    (%rsp),%rdx
mov    $0x1,%al
call   1050 <printf@plt>
movapd 0x70(%rsp),%xmm0
mov    0x180(%rsp),%ecx
mov    0x10(%rsp),%r8
mov    0x178(%rsp),%eax
mov    0x20(%rsp),%rbp
test   %ecx,%ecx
jg     2276 <SBL+0x1086>
jmp    2296 <SBL+0x10a6>
mov    %ecx,%eax
mov    %ecx,%r14d
mov    0x48(%rsp),%r15
mov    0x180(%rsp),%ecx
test   %ecx,%ecx
jg     2276 <SBL+0x1086>
jmp    2296 <SBL+0x10a6>
movabs $0xbff0000000000000,%rax
mov    0x10(%rsp),%rbx
mov    %rax,(%rbx)
mov    0x30(%rsp),%rcx
movl   $0xffffffff,(%rcx)
mov    %rax,0x0(%r13)
mov    0x58(%rsp),%rcx
mov    %rax,(%rcx)
lea    0xe2c(%rip),%rdi
xor    %eax,%eax
mov    %rax,(%rsp)
mov    0x50(%rsp),%r14d
mov    %r14d,%esi
xor    %edx,%edx
xor    %eax,%eax
call   1050 <printf@plt>
mov    %rbx,%r8
mov    0x48(%rsp),%r15
mov    0x20(%rsp),%rbp
mov    0x178(%rsp),%eax
mov    0x180(%rsp),%ecx
movapd 0x70(%rsp),%xmm0
test   %ecx,%ecx
jle    2296 <SBL+0x10a6>
cmp    %eax,0x8(%rsp)
jl     2296 <SBL+0x10a6>
lea    0xe23(%rip),%rdi
mov    %r14d,%esi
mov    (%rsp),%rdx
mov    $0x1,%al
call   1050 <printf@plt>
mov    0x10(%rsp),%r8
mov    0x18(%rsp),%rdx
mov    0x30(%rsp),%rbx
cmpl   $0x0,(%rsp)
je     23ce <SBL+0x11de>
jle    2390 <SBL+0x11a0>
mov    (%rsp),%r15d
lea    -0x1(%r15),%rcx
mov    %r15d,%r9d
and    $0x3,%r9d
cmp    $0x3,%rcx
jae    22ce <SBL+0x10de>
xor    %ecx,%ecx
mov    0x40(%rsp),%rax
jmp    2327 <SBL+0x1137>
mov    %r15d,%edi
and    $0xfffffffc,%edi
xor    %ecx,%ecx
mov    0x40(%rsp),%rax
nopl   0x0(%rax,%rax,1)
movslq (%rbx,%rcx,4),%rsi
movsd  (%rax,%rsi,8),%xmm0
movsd  %xmm0,(%rdx,%rcx,8)
movslq 0x4(%rbx,%rcx,4),%rsi
movsd  (%rax,%rsi,8),%xmm0
movsd  %xmm0,0x8(%rdx,%rcx,8)
movslq 0x8(%rbx,%rcx,4),%rsi
movsd  (%rax,%rsi,8),%xmm0
movsd  %xmm0,0x10(%rdx,%rcx,8)
movslq 0xc(%rbx,%rcx,4),%rsi
movsd  (%rax,%rsi,8),%xmm0
movsd  %xmm0,0x18(%rdx,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rdi
jne    22e0 <SBL+0x10f0>
test   %r9,%r9
je     2358 <SBL+0x1168>
lea    (%rdx,%rcx,8),%rbp
lea    (%rbx,%rcx,4),%rcx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
movslq (%rcx,%rsi,4),%rdi
movsd  (%rax,%rdi,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rsi,8)
add    $0x1,%rsi
cmp    %rsi,%r9
jne    2340 <SBL+0x1150>
cmpl   $0x0,(%rsp)
mov    0x38(%rsp),%r12
jle    2390 <SBL+0x11a0>
shl    $0x3,%r15
mov    %r13,%rdi
mov    0x20(%rsp),%rsi
mov    %r15,%rdx
call   10e0 <memcpy@plt>
mov    0x10(%rsp),%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1070 <memset@plt>
mov    0x18(%rsp),%rdx
mov    0x10(%rsp),%r8
mov    0x20(%rsp),%rbp
mov    %rbp,%rdi
mov    0x28(%rsp),%rbx
mov    %rbx,%rsi
mov    (%rsp),%rcx
xor    %eax,%eax
mov    %rdx,%r13
call   1060 <TriSymGaxpy@plt>
mov    0x48(%rsp),%r15
jmp    23e4 <SBL+0x11f4>
mov    0x30(%rsp),%rbx
mov    0x50(%rsp),%r14d
mov    0x20(%rsp),%rbp
cmpl   $0x0,(%rsp)
jne    22aa <SBL+0x10ba>
movabs $0xbff0000000000000,%rax
mov    %rax,0x0(%rbp)
mov    %rdx,%r13
mov    0x28(%rsp),%rbx
mov    %r15,%rdi
call   1030 <free@plt>
mov    %rbp,%rdi
call   1030 <free@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    0x60(%rsp),%rdi
call   1030 <free@plt>
mov    0x40(%rsp),%rdi
call   1030 <free@plt>
mov    %r13,%rdi
call   1030 <free@plt>
mov    0x88(%rsp),%rdi
call   1030 <free@plt>
mov    0x80(%rsp),%rdi
call   1030 <free@plt>
mov    %r12,%rdi
call   1030 <free@plt>
mov    0xa8(%rsp),%rdi
call   1030 <free@plt>
mov    0xc0(%rsp),%rdi
call   1030 <free@plt>
mov    0x98(%rsp),%rdi
call   1030 <free@plt>
mov    0xa0(%rsp),%rdi
call   1030 <free@plt>
mov    0x170(%rsp),%rax
mov    (%rsp),%rcx
mov    %ecx,(%rax)
mov    %r14d,%eax
add    $0x138,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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