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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double *dvector(int, unsigned long);
double fabs(double);
int /*<<< orphan*/ free_dvector(double *, int, unsigned long);
int /*<<< orphan*/ nrerror(char *);
int /*<<< orphan*/ printf(char *, int, double);
void linbcg(unsigned long n, double b[], double x[], int itol, double tol,
            int itmax, int *iter, double *err) {
  void asolve(unsigned long n, double b[], double x[], int itrnsp);
  void atimes(unsigned long n, double x[], double r[], int itrnsp);
  double snrm(unsigned long n, double sx[], int itol);
  unsigned long j;
  double ak, akden, bk, bkden, bknum, bnrm, dxnrm, xnrm, zm1nrm, znrm;
  double *p, *pp, *r, *rr, *z, *zz;
  p = dvector(1, n);
  pp = dvector(1, n);
  r = dvector(1, n);
  rr = dvector(1, n);
  z = dvector(1, n);
  zz = dvector(1, n);
  *iter = 0;
  atimes(n, x, r, 0);
  for (j = 1; j <= n; j++) {
    r[j] = b[j] - r[j];
    rr[j] = r[j];
  }
  if (itol == 1) {
    bnrm = snrm(n, b, itol);
    asolve(n, r, z, 0);
  } else if (itol == 2) {
    asolve(n, b, z, 0);
    bnrm = snrm(n, z, itol);
    asolve(n, r, z, 0);
  } else if (itol == 3 || itol == 4) {
    asolve(n, b, z, 0);
    bnrm = snrm(n, z, itol);
    asolve(n, r, z, 0);
    znrm = snrm(n, z, itol);
  } else
    nrerror("illegal itol in linbcg");
  while (*iter <= itmax) {
    ++(*iter);
    asolve(n, rr, zz, 1);
    for (bknum = 0.0, j = 1; j <= n; j++)
      bknum += z[j] * rr[j];
    if (*iter == 1) {
      for (j = 1; j <= n; j++) {
        p[j] = z[j];
        pp[j] = zz[j];
      }
    } else {
      bk = bknum / bkden;
      for (j = 1; j <= n; j++) {
        p[j] = bk * p[j] + z[j];
        pp[j] = bk * pp[j] + zz[j];
      }
    }
    bkden = bknum;
    atimes(n, p, z, 0);
    for (akden = 0.0, j = 1; j <= n; j++)
      akden += z[j] * pp[j];
    ak = bknum / akden;
    atimes(n, pp, zz, 1);
    for (j = 1; j <= n; j++) {
      x[j] += ak * p[j];
      r[j] -= ak * z[j];
      rr[j] -= ak * zz[j];
    }
    asolve(n, r, z, 0);
    if (itol == 1)
      *err = snrm(n, r, itol) / bnrm;
    else if (itol == 2)
      *err = snrm(n, z, itol) / bnrm;
    else if (itol == 3 || itol == 4) {
      zm1nrm = znrm;
      znrm = snrm(n, z, itol);
      if (fabs(zm1nrm - znrm) > 1.0e-14 * znrm) {
        dxnrm = fabs(ak) * snrm(n, p, itol);
        *err = znrm / fabs(zm1nrm - znrm) * dxnrm;
      } else {
        *err = znrm / bnrm;
        continue;
      }
      xnrm = snrm(n, x, itol);
      if (*err <= 0.5 * xnrm)
        *err /= xnrm;
      else {
        *err = znrm / bnrm;
        continue;
      }
    }
    printf("iter=%4d err=%12.6f\n", *iter, *err);
    if (*err <= tol)
      break;
  }
  free_dvector(p, 1, n);
  free_dvector(pp, 1, n);
  free_dvector(r, 1, n);
  free_dvector(rr, 1, n);
  free_dvector(z, 1, n);
  free_dvector(zz, 1, n);
}


x86 assembly (clang, -O0):
<linbcg>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd0,%rsp
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
movsd  %xmm0,-0x28(%rbp)
mov    %r8d,-0x2c(%rbp)
mov    %r9,-0x38(%rbp)
mov    -0x8(%rbp),%rsi
mov    $0x1,%edi
call   1080 <dvector@plt>
mov    %rax,-0x98(%rbp)
mov    -0x8(%rbp),%rsi
mov    $0x1,%edi
call   1080 <dvector@plt>
mov    %rax,-0xa0(%rbp)
mov    -0x8(%rbp),%rsi
mov    $0x1,%edi
call   1080 <dvector@plt>
mov    %rax,-0xa8(%rbp)
mov    -0x8(%rbp),%rsi
mov    $0x1,%edi
call   1080 <dvector@plt>
mov    %rax,-0xb0(%rbp)
mov    -0x8(%rbp),%rsi
mov    $0x1,%edi
call   1080 <dvector@plt>
mov    %rax,-0xb8(%rbp)
mov    -0x8(%rbp),%rsi
mov    $0x1,%edi
call   1080 <dvector@plt>
mov    %rax,-0xc0(%rbp)
mov    -0x38(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x8(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0xa8(%rbp),%rdx
xor    %ecx,%ecx
call   1030 <atimes@plt>
movq   $0x1,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x8(%rbp),%rax
ja     12ad <linbcg+0x13d>
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xa8(%rbp),%rax
mov    -0x40(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0xa8(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa8(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xb0(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    1241 <linbcg+0xd1>
cmpl   $0x1,-0x1c(%rbp)
jne    12ea <linbcg+0x17a>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x1c(%rbp),%edx
call   1050 <snrm@plt>
movsd  %xmm0,-0x70(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0xa8(%rbp),%rsi
mov    -0xb8(%rbp),%rdx
xor    %ecx,%ecx
call   1040 <asolve@plt>
jmp    13d1 <linbcg+0x261>
cmpl   $0x2,-0x1c(%rbp)
jne    1340 <linbcg+0x1d0>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0xb8(%rbp),%rdx
xor    %ecx,%ecx
call   1040 <asolve@plt>
mov    -0x8(%rbp),%rdi
mov    -0xb8(%rbp),%rsi
mov    -0x1c(%rbp),%edx
call   1050 <snrm@plt>
movsd  %xmm0,-0x70(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0xa8(%rbp),%rsi
mov    -0xb8(%rbp),%rdx
xor    %ecx,%ecx
call   1040 <asolve@plt>
jmp    13cc <linbcg+0x25c>
cmpl   $0x3,-0x1c(%rbp)
je     1354 <linbcg+0x1e4>
cmpl   $0x4,-0x1c(%rbp)
jne    13bb <linbcg+0x24b>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0xb8(%rbp),%rdx
xor    %ecx,%ecx
call   1040 <asolve@plt>
mov    -0x8(%rbp),%rdi
mov    -0xb8(%rbp),%rsi
mov    -0x1c(%rbp),%edx
call   1050 <snrm@plt>
movsd  %xmm0,-0x70(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0xa8(%rbp),%rsi
mov    -0xb8(%rbp),%rdx
xor    %ecx,%ecx
call   1040 <asolve@plt>
mov    -0x8(%rbp),%rdi
mov    -0xb8(%rbp),%rsi
mov    -0x1c(%rbp),%edx
call   1050 <snrm@plt>
movsd  %xmm0,-0x90(%rbp)
ff
jmp    13c7 <linbcg+0x257>
lea    0xc5e(%rip),%rdi
call   1060 <nrerror@plt>
jmp    13cc <linbcg+0x25c>
jmp    13d1 <linbcg+0x261>
jmp    13d6 <linbcg+0x266>
mov    -0x38(%rbp),%rax
mov    (%rax),%eax
cmp    -0x2c(%rbp),%eax
jg     1961 <linbcg+0x7f1>
mov    -0x38(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
mov    -0x8(%rbp),%rdi
mov    -0xb0(%rbp),%rsi
mov    -0xc0(%rbp),%rdx
mov    $0x1,%ecx
call   1040 <asolve@plt>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
movq   $0x1,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x8(%rbp),%rax
ja     146d <linbcg+0x2fd>
mov    -0xb8(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xb0(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    141c <linbcg+0x2ac>
mov    -0x38(%rbp),%rax
cmpl   $0x1,(%rax)
jne    14e6 <linbcg+0x376>
movq   $0x1,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x8(%rbp),%rax
ja     14e1 <linbcg+0x371>
mov    -0xb8(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x98(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc0(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xa0(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    1482 <linbcg+0x312>
jmp    159b <linbcg+0x42b>
movsd  -0x68(%rbp),%xmm0
divsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movq   $0x1,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x8(%rbp),%rax
ja     1596 <linbcg+0x426>
movsd  -0x58(%rbp),%xmm0
mov    -0x98(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0xb8(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x98(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm0
mov    -0xa0(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0xc0(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xa0(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    14fd <linbcg+0x38d>
jmp    159b <linbcg+0x42b>
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x98(%rbp),%rsi
mov    -0xb8(%rbp),%rdx
xor    %ecx,%ecx
call   1030 <atimes@plt>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
movq   $0x1,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x8(%rbp),%rax
ja     161f <linbcg+0x4af>
mov    -0xb8(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xa0(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    15ce <linbcg+0x45e>
movsd  -0x68(%rbp),%xmm0
divsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0xa0(%rbp),%rsi
mov    -0xc0(%rbp),%rdx
mov    $0x1,%ecx
call   1030 <atimes@plt>
movq   $0x1,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x8(%rbp),%rax
ja     1732 <linbcg+0x5c2>
movsd  -0x48(%rbp),%xmm0
mov    -0x98(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x48(%rbp),%xmm0
mov    -0xb8(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0xa8(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x48(%rbp),%xmm0
mov    -0xc0(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0xb0(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    1652 <linbcg+0x4e2>
mov    -0x8(%rbp),%rdi
mov    -0xa8(%rbp),%rsi
mov    -0xb8(%rbp),%rdx
xor    %ecx,%ecx
call   1040 <asolve@plt>
cmpl   $0x1,-0x1c(%rbp)
jne    177a <linbcg+0x60a>
mov    -0x8(%rbp),%rdi
mov    -0xa8(%rbp),%rsi
mov    -0x1c(%rbp),%edx
call   1050 <snrm@plt>
divsd  -0x70(%rbp),%xmm0
mov    0x10(%rbp),%rax
movsd  %xmm0,(%rax)
jmp    1926 <linbcg+0x7b6>
cmpl   $0x2,-0x1c(%rbp)
jne    17a9 <linbcg+0x639>
mov    -0x8(%rbp),%rdi
mov    -0xb8(%rbp),%rsi
mov    -0x1c(%rbp),%edx
call   1050 <snrm@plt>
divsd  -0x70(%rbp),%xmm0
mov    0x10(%rbp),%rax
movsd  %xmm0,(%rax)
jmp    1921 <linbcg+0x7b1>
cmpl   $0x3,-0x1c(%rbp)
je     17bd <linbcg+0x64d>
cmpl   $0x4,-0x1c(%rbp)
jne    191c <linbcg+0x7ac>
movsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x8(%rbp),%rdi
mov    -0xb8(%rbp),%rsi
mov    -0x1c(%rbp),%edx
call   1050 <snrm@plt>
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
subsd  -0x90(%rbp),%xmm0
ff
movaps 0x811(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0x7f5(%rip),%xmm1
mulsd  -0x90(%rbp),%xmm1
ff
ucomisd %xmm1,%xmm0
jbe    1895 <linbcg+0x725>
movsd  -0x48(%rbp),%xmm0
movaps 0x7e7(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x8(%rbp),%rdi
mov    -0x98(%rbp),%rsi
mov    -0x1c(%rbp),%edx
call   1050 <snrm@plt>
movaps %xmm0,%xmm1
movsd  -0xc8(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0x88(%rbp),%xmm1
ff
subsd  -0x90(%rbp),%xmm1
ff
movaps 0x795(%rip),%xmm2
pand   %xmm2,%xmm1
divsd  %xmm1,%xmm0
mulsd  -0x78(%rbp),%xmm0
mov    0x10(%rbp),%rax
movsd  %xmm0,(%rax)
jmp    18af <linbcg+0x73f>
movsd  -0x90(%rbp),%xmm0
ff
divsd  -0x70(%rbp),%xmm0
mov    0x10(%rbp),%rax
movsd  %xmm0,(%rax)
jmp    13d6 <linbcg+0x266>
mov    -0x8(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x1c(%rbp),%edx
call   1050 <snrm@plt>
movsd  %xmm0,-0x80(%rbp)
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm1
movsd  0x734(%rip),%xmm0
mulsd  -0x80(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     18fd <linbcg+0x78d>
movsd  -0x80(%rbp),%xmm1
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
jmp    1917 <linbcg+0x7a7>
movsd  -0x90(%rbp),%xmm0
ff
divsd  -0x70(%rbp),%xmm0
mov    0x10(%rbp),%rax
movsd  %xmm0,(%rax)
jmp    13d6 <linbcg+0x266>
jmp    191c <linbcg+0x7ac>
jmp    1921 <linbcg+0x7b1>
jmp    1926 <linbcg+0x7b6>
mov    -0x38(%rbp),%rax
mov    (%rax),%esi
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
lea    0x6fc(%rip),%rdi
call   1070 <printf@plt>
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm1
movsd  -0x28(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     195c <linbcg+0x7ec>
jmp    1961 <linbcg+0x7f1>
jmp    13d6 <linbcg+0x266>
mov    -0x98(%rbp),%rdi
mov    -0x8(%rbp),%rdx
mov    $0x1,%esi
call   1090 <free_dvector@plt>
mov    -0xa0(%rbp),%rdi
mov    -0x8(%rbp),%rdx
mov    $0x1,%esi
call   1090 <free_dvector@plt>
mov    -0xa8(%rbp),%rdi
mov    -0x8(%rbp),%rdx
mov    $0x1,%esi
call   1090 <free_dvector@plt>
mov    -0xb0(%rbp),%rdi
mov    -0x8(%rbp),%rdx
mov    $0x1,%esi
call   1090 <free_dvector@plt>
mov    -0xb8(%rbp),%rdi
mov    -0x8(%rbp),%rdx
mov    $0x1,%esi
call   1090 <free_dvector@plt>
mov    -0xc0(%rbp),%rdi
mov    -0x8(%rbp),%rdx
mov    $0x1,%esi
call   1090 <free_dvector@plt>
add    $0xd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<linbcg>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x128,%rsp
mov    %r9,0x20(%rsp)
mov    %r8d,0x4c(%rsp)
movsd  %xmm0,0x120(%rsp)
mov    %rcx,0x90(%rsp)
mov    %rdx,%r12
mov    %rsi,0x18(%rsp)
mov    %rdi,%rbx
mov    0x160(%rsp),%rax
mov    %rax,0x30(%rsp)
mov    $0x1,%edi
mov    %rbx,%rsi
call   1080 <dvector@plt>
mov    %rax,0x88(%rsp)
mov    $0x1,%edi
mov    %rbx,%rsi
call   1080 <dvector@plt>
mov    %rax,%r15
mov    $0x1,%edi
mov    %rbx,%rsi
call   1080 <dvector@plt>
mov    %rax,%rbp
mov    $0x1,%edi
mov    %rbx,%rsi
call   1080 <dvector@plt>
mov    %rax,%r14
mov    $0x1,%edi
mov    %rbx,%rsi
call   1080 <dvector@plt>
mov    %rax,%r13
mov    $0x1,%edi
mov    %rbx,%rsi
call   1080 <dvector@plt>
mov    %rax,0x10(%rsp)
mov    0x20(%rsp),%rax
movl   $0x0,(%rax)
mov    %rbx,%rdi
mov    %r12,0xd0(%rsp)
mov    %r12,%rsi
mov    %rbp,%rdx
xor    %ecx,%ecx
call   1030 <atimes@plt>
mov    0x18(%rsp),%rsi
mov    %rbx,%rdi
test   %rbx,%rbx
mov    %rbx,(%rsp)
je     1452 <linbcg+0x2e2>
mov    $0x1,%r11d
cmp    $0x4,%rdi
jae    12de <linbcg+0x16e>
mov    %r11,%rcx
test   $0x1,%dil
je     1286 <linbcg+0x116>
movsd  (%rsi,%r11,8),%xmm0
subsd  0x0(%rbp,%r11,8),%xmm0
movsd  %xmm0,0x0(%rbp,%r11,8)
movsd  %xmm0,(%r14,%r11,8)
lea    0x1(%r11),%rcx
cmp    %rdi,%r11
je     1452 <linbcg+0x2e2>
lea    0x1(%rdi),%rax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rsi,%rcx,8),%xmm0
subsd  0x0(%rbp,%rcx,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rcx,8)
movsd  %xmm0,(%r14,%rcx,8)
movsd  0x8(%rsi,%rcx,8),%xmm0
subsd  0x8(%rbp,%rcx,8),%xmm0
movsd  %xmm0,0x8(%rbp,%rcx,8)
movsd  %xmm0,0x8(%r14,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rax
jne    12a0 <linbcg+0x130>
jmp    1452 <linbcg+0x2e2>
lea    0x8(,%rdi,8),%rdx
add    %rbp,%rdx
mov    %rbp,%rcx
add    $0x8,%rcx
lea    0x8(%r14),%r12
mov    %rdi,%rbx
lea    (%r14,%rdi,8),%rdi
add    $0x8,%rdi
lea    0x8(%rsi),%rax
lea    (%rsi,%rbx,8),%rbx
add    $0x8,%rbx
cmp    %rdi,%rcx
setb   %r9b
cmp    %rdx,%r12
setb   %r10b
cmp    %rbx,%rcx
setb   %cl
cmp    %rdx,%rax
setb   %r8b
cmp    %rbx,%r12
setb   %dl
cmp    %rdi,%rax
setb   %sil
test   %r10b,%r9b
jne    2089 <linbcg+0xf19>
and    %r8b,%cl
jne    2089 <linbcg+0xf19>
and    %sil,%dl
mov    (%rsp),%rdi
mov    0x18(%rsp),%rsi
jne    125f <linbcg+0xef>
mov    %rdi,%r11
and    $0xfffffffffffffffc,%r11
lea    -0x4(%r11),%rcx
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     20a0 <linbcg+0xf30>
mov    %rdx,%rax
and    $0xfffffffffffffffe,%rax
mov    $0x1,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd (%rsi,%rcx,8),%xmm0
movupd 0x10(%rsi,%rcx,8),%xmm1
movupd 0x0(%rbp,%rcx,8),%xmm2
subpd  %xmm2,%xmm0
movupd 0x10(%rbp,%rcx,8),%xmm2
subpd  %xmm2,%xmm1
movupd %xmm0,0x0(%rbp,%rcx,8)
movupd %xmm1,0x10(%rbp,%rcx,8)
movupd %xmm0,(%r14,%rcx,8)
movupd %xmm1,0x10(%r14,%rcx,8)
movupd 0x20(%rsi,%rcx,8),%xmm0
movupd 0x30(%rsi,%rcx,8),%xmm1
movupd 0x20(%rbp,%rcx,8),%xmm2
subpd  %xmm2,%xmm0
movupd 0x30(%rbp,%rcx,8),%xmm2
subpd  %xmm2,%xmm1
movupd %xmm0,0x20(%rbp,%rcx,8)
movupd %xmm1,0x30(%rbp,%rcx,8)
movupd %xmm0,0x20(%r14,%rcx,8)
movupd %xmm1,0x30(%r14,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rax
jne    1390 <linbcg+0x220>
test   $0x1,%dl
je     1449 <linbcg+0x2d9>
movupd (%rsi,%rcx,8),%xmm0
movupd 0x10(%rsi,%rcx,8),%xmm1
movupd 0x0(%rbp,%rcx,8),%xmm2
subpd  %xmm2,%xmm0
movupd 0x10(%rbp,%rcx,8),%xmm2
subpd  %xmm2,%xmm1
movupd %xmm0,0x0(%rbp,%rcx,8)
movupd %xmm1,0x10(%rbp,%rcx,8)
movupd %xmm0,(%r14,%rcx,8)
movupd %xmm1,0x10(%r14,%rcx,8)
cmp    %rdi,%r11
jne    2097 <linbcg+0xf27>
mov    0x90(%rsp),%rbx
cmp    $0x1,%ebx
mov    0x88(%rsp),%r12
mov    %rbp,0x40(%rsp)
jne    1476 <linbcg+0x306>
mov    %rdi,%rbx
mov    $0x1,%edx
jmp    1497 <linbcg+0x327>
cmp    $0x2,%ebx
jne    2022 <linbcg+0xeb2>
mov    %rdi,%rbx
mov    %r13,%rdx
xor    %ecx,%ecx
call   1040 <asolve@plt>
mov    %rbx,%rdi
mov    %r13,%rsi
mov    $0x2,%edx
call   1050 <snrm@plt>
movsd  %xmm0,0x38(%rsp)
mov    %rbx,%rdi
mov    %rbp,%rsi
mov    %r13,%rdx
xor    %ecx,%ecx
call   1040 <asolve@plt>
mov    0x20(%rsp),%rdi
mov    0x10(%rsp),%rbp
mov    (%rdi),%eax
cmp    0x4c(%rsp),%eax
jle    153b <linbcg+0x3cb>
mov    %r12,%rdi
mov    $0x1,%esi
mov    (%rsp),%rbx
mov    %rbx,%rdx
call   1090 <free_dvector@plt>
mov    %r15,%rdi
mov    $0x1,%esi
mov    %rbx,%rdx
call   1090 <free_dvector@plt>
mov    0x40(%rsp),%rdi
mov    $0x1,%esi
mov    %rbx,%rdx
call   1090 <free_dvector@plt>
mov    %r14,%rdi
mov    $0x1,%esi
mov    %rbx,%rdx
call   1090 <free_dvector@plt>
mov    %r13,%rdi
mov    $0x1,%esi
mov    %rbx,%rdx
call   1090 <free_dvector@plt>
mov    %rbp,%rdi
mov    $0x1,%esi
mov    %rbx,%rdx
add    $0x128,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1090 <free_dvector@plt>
mov    (%rsp),%rcx
lea    (%r12,%rcx,8),%r10
add    $0x8,%r10
mov    %r12,%r8
add    $0x8,%r8
lea    0x8(%r15),%rsi
mov    %rsi,0x80(%rsp)
mov    (%rsp),%rcx
lea    (%r15,%rcx,8),%rdx
add    $0x8,%rdx
mov    %rdx,0x18(%rsp)
lea    0x8(%r13),%rcx
mov    %rcx,0x58(%rsp)
mov    (%rsp),%rcx
lea    0x8(,%rcx,8),%rbp
add    %r13,%rbp
mov    %rbp,0x28(%rsp)
mov    0x10(%rsp),%rcx
add    $0x8,%rcx
mov    %rcx,0x50(%rsp)
mov    (%rsp),%rcx
lea    -0x2(%rcx),%r11
mov    %r11,0x118(%rsp)
shr    %r11
add    $0x1,%r11
mov    (%rsp),%rcx
lea    -0x4(%rcx),%r9
mov    %r9,0x108(%rsp)
shr    $0x2,%r9
add    $0x1,%r9
mov    (%rsp),%rbx
and    $0x3,%ebx
mov    %rbx,0x68(%rsp)
mov    (%rsp),%rcx
and    $0xfffffffffffffffc,%rcx
mov    %rcx,0x60(%rsp)
cmp    %rdx,%r8
setb   %cl
cmp    %r10,%rsi
setb   %dl
and    %cl,%dl
cmp    %rbp,%r8
setb   %bl
cmp    %r10,0x58(%rsp)
setb   %cl
and    %bl,%cl
mov    (%rsp),%rsi
mov    0x10(%rsp),%rbp
lea    0x8(,%rsi,8),%rsi
add    %rbp,%rsi
mov    %rsi,0x70(%rsp)
or     %dl,%cl
mov    %r8,0xc8(%rsp)
cmp    %rsi,%r8
setb   %dl
cmp    %r10,0x50(%rsp)
mov    0x10(%rsp),%rbp
mov    (%rsp),%rbx
setb   %r10b
and    %dl,%r10b
mov    0x80(%rsp),%rsi
cmp    0x28(%rsp),%rsi
setb   0x28(%rsp)
mov    0x58(%rsp),%rdx
mov    0x18(%rsp),%r8
cmp    %r8,%rdx
setb   %dl
and    0x28(%rsp),%dl
or     %r10b,%dl
or     %cl,%dl
cmp    0x70(%rsp),%rsi
setb   %r10b
cmp    %r8,0x50(%rsp)
setb   %cl
and    %r10b,%cl
or     %dl,%cl
mov    %cl,0xf(%rsp)
mov    %rbx,%rcx
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0xf8(%rsp)
mov    %rbx,%rcx
or     $0x1,%rcx
mov    %rcx,0xf0(%rsp)
mov    %r11,%rcx
mov    %r11,0x110(%rsp)
and    $0xfffffffffffffffe,%r11
mov    %r11,0xe0(%rsp)
mov    %r9,%rcx
mov    %r9,0x100(%rsp)
and    $0xfffffffffffffffe,%r9
mov    %r9,0xd8(%rsp)
mov    0x90(%rsp),%rcx
add    $0xfffffffd,%ecx
mov    %ecx,0x9c(%rsp)
lea    0x1(%rbx),%rcx
mov    %rcx,0xc0(%rsp)
lea    -0x1(%rbx),%rcx
mov    %rcx,0x28(%rsp)
mov    0x60(%rsp),%rcx
add    $0x1,%rcx
mov    %rcx,0xe8(%rsp)
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%eax
mov    %eax,(%rdi)
mov    (%rsp),%rbx
mov    %rbx,%rdi
mov    %r14,%rsi
mov    %rbp,%rdx
mov    $0x1,%ecx
call   1040 <asolve@plt>
xorpd  %xmm4,%xmm4
test   %rbx,%rbx
je     18b0 <linbcg+0x740>
cmpq   $0x3,0x28(%rsp)
jae    1770 <linbcg+0x600>
xorpd  %xmm4,%xmm4
mov    $0x1,%eax
mov    0x20(%rsp),%rsi
mov    0x68(%rsp),%rdi
test   %rdi,%rdi
jne    17ea <linbcg+0x67a>
jmp    1817 <linbcg+0x6a7>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xorpd  %xmm4,%xmm4
xor    %eax,%eax
mov    0x20(%rsp),%rsi
mov    0x68(%rsp),%rdi
mov    0x60(%rsp),%rcx
cs nopw 0x0(%rax,%rax,1)
nop
movsd  0x8(%r13,%rax,8),%xmm0
movsd  0x10(%r13,%rax,8),%xmm1
mulsd  0x8(%r14,%rax,8),%xmm0
mulsd  0x10(%r14,%rax,8),%xmm1
addsd  %xmm4,%xmm0
movsd  0x18(%r13,%rax,8),%xmm2
mulsd  0x18(%r14,%rax,8),%xmm2
addsd  %xmm0,%xmm1
movsd  0x20(%r13,%rax,8),%xmm4
mulsd  0x20(%r14,%rax,8),%xmm4
addsd  %xmm1,%xmm2
addsd  %xmm2,%xmm4
add    $0x4,%rax
cmp    %rax,%rcx
jne    1790 <linbcg+0x620>
add    $0x1,%rax
test   %rdi,%rdi
je     1817 <linbcg+0x6a7>
lea    (%r14,%rax,8),%rcx
lea    0x0(,%rax,8),%rax
add    %r13,%rax
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movsd  (%rax,%rdx,8),%xmm0
mulsd  (%rcx,%rdx,8),%xmm0
addsd  %xmm0,%xmm4
add    $0x1,%rdx
cmp    %rdx,%rdi
jne    1800 <linbcg+0x690>
cmpl   $0x1,(%rsi)
jne    1860 <linbcg+0x6f0>
test   %rbx,%rbx
je     18b0 <linbcg+0x740>
cmp    $0x4,%rbx
setb   %al
or     0xf(%rsp),%al
mov    $0x1,%eax
jne    1bb2 <linbcg+0xa42>
cmpq   $0x4,0x108(%rsp)
jae    1ad9 <linbcg+0x969>
xor    %eax,%eax
mov    0x10(%rsp),%rdx
jmp    1b5a <linbcg+0x9ea>
cs nopw 0x0(%rax,%rax,1)
test   %rbx,%rbx
je     18b0 <linbcg+0x740>
movapd %xmm4,%xmm0
divsd  0x18(%rsp),%xmm0
cmp    $0x1,%rbx
sete   %al
or     0xf(%rsp),%al
mov    $0x1,%eax
jne    1d5c <linbcg+0xbec>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x2,0x118(%rsp)
jae    1c6a <linbcg+0xafa>
xor    %eax,%eax
mov    0x10(%rsp),%rdx
jmp    1cfc <linbcg+0xb8c>
nopl   0x0(%rax,%rax,1)
movsd  %xmm4,0x18(%rsp)
mov    (%rsp),%rdi
mov    %r12,%rsi
mov    %r13,%rdx
xor    %ecx,%ecx
call   1030 <atimes@plt>
mov    (%rsp),%rbx
movsd  0x18(%rsp),%xmm0
divsd  0x1757(%rip),%xmm0
movapd %xmm0,0x70(%rsp)
mov    %rbx,%rdi
mov    %r15,%rsi
mov    %rbp,%rdx
mov    $0x1,%ecx
call   1030 <atimes@plt>
mov    0x40(%rsp),%rsi
mov    %rbx,%rdi
mov    %r13,%rdx
xor    %ecx,%ecx
mov    %rsi,%rbp
call   1040 <asolve@plt>
mov    0x90(%rsp),%rax
cmp    $0x1,%eax
jne    1930 <linbcg+0x7c0>
mov    %rbx,%rdi
mov    %rbp,%rsi
mov    $0x1,%edx
jmp    1941 <linbcg+0x7d1>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cmp    $0x2,%eax
jne    19b0 <linbcg+0x840>
mov    (%rsp),%rdi
mov    %r13,%rsi
mov    $0x2,%edx
call   1050 <snrm@plt>
divsd  0x38(%rsp),%xmm0
mov    0x30(%rsp),%r12
movsd  %xmm0,(%r12)
mov    0x20(%rsp),%rax
mov    0x10(%rsp),%rbp
mov    (%rax),%esi
lea    0x16e5(%rip),%rdi
call   1070 <printf@plt>
mov    0x20(%rsp),%rdi
movsd  0x120(%rsp),%xmm0
ucomisd (%r12),%xmm0
mov    0x88(%rsp),%r12
jae    14c4 <linbcg+0x354>
mov    (%rdi),%eax
cmp    0x4c(%rsp),%eax
jle    1710 <linbcg+0x5a0>
jmp    14c4 <linbcg+0x354>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmpl   $0x2,0x9c(%rsp)
02
mov    0x10(%rsp),%rbp
jae    1ac4 <linbcg+0x954>
mov    (%rsp),%rdi
mov    %r13,%rsi
mov    %rax,%rbx
mov    %ebx,%edx
call   1050 <snrm@plt>
movapd %xmm0,%xmm3
movapd 0xa0(%rsp),%xmm1
subsd  %xmm0,%xmm1
movapd 0x1623(%rip),%xmm2
andpd  %xmm2,%xmm1
mulsd  0x1627(%rip),%xmm0
ucomisd %xmm0,%xmm1
jbe    1a9e <linbcg+0x92e>
movapd 0x70(%rsp),%xmm0
andpd  %xmm2,%xmm0
movapd %xmm0,0x70(%rsp)
mov    (%rsp),%rdi
mov    %r12,%rsi
mov    %ebx,%edx
movapd %xmm1,0xa0(%rsp)
movsd  %xmm3,0xb8(%rsp)
call   1050 <snrm@plt>
mulsd  0x70(%rsp),%xmm0
movsd  0xb8(%rsp),%xmm1
divsd  0xa0(%rsp),%xmm1
mulsd  %xmm0,%xmm1
mov    0x30(%rsp),%r12
movsd  %xmm1,(%r12)
mov    (%rsp),%rdi
mov    0xd0(%rsp),%rsi
mov    %ebx,%edx
call   1050 <snrm@plt>
movsd  0xb8(%rsp),%xmm3
movapd %xmm0,%xmm1
movsd  (%r12),%xmm0
mov    0x88(%rsp),%r12
movapd %xmm1,%xmm2
mulsd  0x1594(%rip),%xmm2
ucomisd %xmm0,%xmm2
jae    2005 <linbcg+0xe95>
movapd %xmm3,%xmm0
divsd  0x38(%rsp),%xmm0
mov    0x30(%rsp),%rax
movsd  %xmm0,(%rax)
movapd %xmm3,0xa0(%rsp)
mov    0x20(%rsp),%rdi
jmp    1991 <linbcg+0x821>
mov    0x30(%rsp),%r12
movsd  (%r12),%xmm0
mov    0x20(%rsp),%rax
jmp    1961 <linbcg+0x7f1>
mov    0xd8(%rsp),%rcx
xor    %eax,%eax
mov    0x10(%rsp),%rdx
nopl   0x0(%rax,%rax,1)
movups 0x8(%r13,%rax,8),%xmm0
movups 0x18(%r13,%rax,8),%xmm1
movups %xmm0,0x8(%r12,%rax,8)
movups %xmm1,0x18(%r12,%rax,8)
movups 0x8(%rdx,%rax,8),%xmm0
movups 0x18(%rdx,%rax,8),%xmm1
movups %xmm0,0x8(%r15,%rax,8)
movups %xmm1,0x18(%r15,%rax,8)
movups 0x28(%r13,%rax,8),%xmm0
movups 0x38(%r13,%rax,8),%xmm1
movups %xmm0,0x28(%r12,%rax,8)
movups %xmm1,0x38(%r12,%rax,8)
movupd 0x28(%rdx,%rax,8),%xmm0
movupd 0x38(%rdx,%rax,8),%xmm1
movupd %xmm0,0x28(%r15,%rax,8)
movupd %xmm1,0x38(%r15,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    1af0 <linbcg+0x980>
testb  $0x1,0x100(%rsp)
01
mov    (%rsp),%rcx
je     1b9f <linbcg+0xa2f>
shl    $0x3,%rax
or     $0x8,%rax
movups 0x0(%r13,%rax,1),%xmm0
movups 0x10(%r13,%rax,1),%xmm1
movups %xmm0,(%r12,%rax,1)
movups %xmm1,0x10(%r12,%rax,1)
movupd (%rdx,%rax,1),%xmm0
movupd 0x10(%rdx,%rax,1),%xmm1
movupd %xmm0,(%r15,%rax,1)
movupd %xmm1,0x10(%r15,%rax,1)
mov    0xe8(%rsp),%rax
cmp    %rcx,0x60(%rsp)
je     1e50 <linbcg+0xce0>
mov    %rax,%rdi
mov    (%rsp),%rcx
test   $0x1,%cl
je     1bdf <linbcg+0xa6f>
movsd  0x0(%r13,%rax,8),%xmm0
movsd  %xmm0,(%r12,%rax,8)
mov    0x10(%rsp),%rdx
movsd  (%rdx,%rax,8),%xmm0
movsd  %xmm0,(%r15,%rax,8)
lea    0x1(%rax),%rdi
cmp    %rcx,%rax
je     1e50 <linbcg+0xce0>
mov    0xc0(%rsp),%rax
sub    %rdi,%rax
mov    0x80(%rsp),%rcx
lea    (%rcx,%rdi,8),%rcx
mov    0x50(%rsp),%rdx
lea    (%rdx,%rdi,8),%rdx
mov    0xc8(%rsp),%rsi
lea    (%rsi,%rdi,8),%rsi
mov    0x58(%rsp),%rbp
lea    0x0(,%rdi,8),%rdi
add    %rbp,%rdi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
movsd  -0x8(%rdi,%rbp,8),%xmm0
movsd  %xmm0,-0x8(%rsi,%rbp,8)
movsd  -0x8(%rdx,%rbp,8),%xmm0
movsd  %xmm0,-0x8(%rcx,%rbp,8)
movsd  (%rdi,%rbp,8),%xmm0
movsd  %xmm0,(%rsi,%rbp,8)
movsd  (%rdx,%rbp,8),%xmm0
movsd  %xmm0,(%rcx,%rbp,8)
add    $0x2,%rbp
cmp    %rbp,%rax
jne    1c30 <linbcg+0xac0>
jmp    1e50 <linbcg+0xce0>
mov    0xe0(%rsp),%rcx
xor    %eax,%eax
mov    0x10(%rsp),%rdx
nopl   0x0(%rax)
movupd 0x8(%r12,%rax,8),%xmm2
movupd 0x8(%r13,%rax,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm3,%xmm2
movupd %xmm2,0x8(%r12,%rax,8)
movupd 0x8(%r15,%rax,8),%xmm2
movupd 0x8(%rdx,%rax,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm3,%xmm2
movupd %xmm2,0x8(%r15,%rax,8)
movupd 0x18(%r12,%rax,8),%xmm2
movupd 0x18(%r13,%rax,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm3,%xmm2
movupd %xmm2,0x18(%r12,%rax,8)
movupd 0x18(%r15,%rax,8),%xmm2
movupd 0x18(%rdx,%rax,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm3,%xmm2
movupd %xmm2,0x18(%r15,%rax,8)
add    $0x4,%rax
add    $0xfffffffffffffffe,%rcx
jne    1c80 <linbcg+0xb10>
testb  $0x1,0x110(%rsp)
01
mov    (%rsp),%rcx
je     1d46 <linbcg+0xbd6>
shl    $0x3,%rax
or     $0x8,%rax
movupd (%r12,%rax,1),%xmm2
movupd 0x0(%r13,%rax,1),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm3,%xmm2
movupd %xmm2,(%r12,%rax,1)
movupd (%r15,%rax,1),%xmm2
movupd (%rdx,%rax,1),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm3,%xmm2
movupd %xmm2,(%r15,%rax,1)
mov    0xf0(%rsp),%rax
cmp    %rcx,0xf8(%rsp)
je     1e50 <linbcg+0xce0>
mov    %rax,%rdi
mov    (%rsp),%rcx
test   $0x1,%cl
je     1d9d <linbcg+0xc2d>
movsd  (%r12,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x0(%r13,%rax,8),%xmm1
movsd  %xmm1,(%r12,%rax,8)
movsd  (%r15,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
mov    0x10(%rsp),%rdx
addsd  (%rdx,%rax,8),%xmm1
movsd  %xmm1,(%r15,%rax,8)
lea    0x1(%rax),%rdi
cmp    %rcx,%rax
je     1e50 <linbcg+0xce0>
mov    0xc0(%rsp),%rax
sub    %rdi,%rax
mov    0x50(%rsp),%rcx
lea    (%rcx,%rdi,8),%rcx
mov    0x80(%rsp),%rdx
lea    (%rdx,%rdi,8),%rdx
mov    0x58(%rsp),%rsi
lea    (%rsi,%rdi,8),%rsi
mov    0xc8(%rsp),%rbp
lea    0x0(,%rdi,8),%rdi
add    %rbp,%rdi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  -0x8(%rdi,%rbp,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  -0x8(%rsi,%rbp,8),%xmm1
movsd  %xmm1,-0x8(%rdi,%rbp,8)
movsd  -0x8(%rdx,%rbp,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  -0x8(%rcx,%rbp,8),%xmm1
movsd  %xmm1,-0x8(%rdx,%rbp,8)
movsd  (%rdi,%rbp,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rsi,%rbp,8),%xmm1
movsd  %xmm1,(%rdi,%rbp,8)
movsd  (%rdx,%rbp,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rcx,%rbp,8),%xmm1
movsd  %xmm1,(%rdx,%rbp,8)
add    $0x2,%rbp
cmp    %rbp,%rax
jne    1df0 <linbcg+0xc80>
nopl   0x0(%rax,%rax,1)
movsd  %xmm4,0x18(%rsp)
mov    (%rsp),%rbx
mov    %rbx,%rdi
mov    %r12,%rsi
mov    %r13,%rdx
xor    %ecx,%ecx
call   1030 <atimes@plt>
test   %rbx,%rbx
je     1e98 <linbcg+0xd28>
cmpq   $0x3,0x28(%rsp)
jae    1ea2 <linbcg+0xd32>
xorpd  %xmm3,%xmm3
mov    $0x1,%eax
mov    0x10(%rsp),%rbp
mov    0x68(%rsp),%rsi
test   $0x3,%bl
jne    1f1f <linbcg+0xdaf>
jmp    1f47 <linbcg+0xdd7>
mov    0x10(%rsp),%rbp
jmp    18cb <linbcg+0x75b>
xorpd  %xmm3,%xmm3
xor    %eax,%eax
mov    0x68(%rsp),%rsi
mov    0x60(%rsp),%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  0x8(%r13,%rax,8),%xmm0
movsd  0x10(%r13,%rax,8),%xmm1
mulsd  0x8(%r15,%rax,8),%xmm0
mulsd  0x10(%r15,%rax,8),%xmm1
addsd  %xmm3,%xmm0
movsd  0x18(%r13,%rax,8),%xmm2
mulsd  0x18(%r15,%rax,8),%xmm2
addsd  %xmm0,%xmm1
movsd  0x20(%r13,%rax,8),%xmm3
mulsd  0x20(%r15,%rax,8),%xmm3
addsd  %xmm1,%xmm2
addsd  %xmm2,%xmm3
add    $0x4,%rax
cmp    %rax,%rcx
jne    1ec0 <linbcg+0xd50>
add    $0x1,%rax
mov    0x10(%rsp),%rbp
test   $0x3,%bl
je     1f47 <linbcg+0xdd7>
lea    (%r15,%rax,8),%rcx
lea    0x0(,%rax,8),%rax
add    %r13,%rax
xor    %edx,%edx
movsd  (%rax,%rdx,8),%xmm0
mulsd  (%rcx,%rdx,8),%xmm0
addsd  %xmm0,%xmm3
add    $0x1,%rdx
cmp    %rdx,%rsi
jne    1f30 <linbcg+0xdc0>
movsd  %xmm3,0x70(%rsp)
mov    %rbx,%rdi
mov    %r15,%rsi
mov    %rbp,%rdx
mov    $0x1,%ecx
call   1030 <atimes@plt>
movsd  0x18(%rsp),%xmm2
movapd %xmm2,%xmm3
divsd  0x70(%rsp),%xmm3
test   %rbx,%rbx
movapd %xmm3,0x70(%rsp)
je     1ffa <linbcg+0xe8a>
movapd %xmm3,%xmm0
xorpd  0x1079(%rip),%xmm0
xor    %eax,%eax
mov    0xd0(%rsp),%rcx
mov    0x40(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
movsd  0x8(%r12,%rax,8),%xmm1
mulsd  %xmm3,%xmm1
addsd  0x8(%rcx,%rax,8),%xmm1
movsd  %xmm1,0x8(%rcx,%rax,8)
movsd  0x8(%r13,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x8(%rsi,%rax,8),%xmm1
movsd  %xmm1,0x8(%rsi,%rax,8)
movsd  0x8(%rbp,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x8(%r14,%rax,8),%xmm1
movsd  %xmm1,0x8(%r14,%rax,8)
add    $0x1,%rax
cmp    %rax,%rbx
jne    1fa0 <linbcg+0xe30>
movsd  %xmm2,0x18(%rsp)
jmp    18f7 <linbcg+0x787>
movsd  %xmm2,0x18(%rsp)
jmp    18f2 <linbcg+0x782>
divsd  %xmm1,%xmm0
mov    0x30(%rsp),%r12
movsd  %xmm0,(%r12)
movapd %xmm3,0xa0(%rsp)
jmp    1acf <linbcg+0x95f>
lea    -0x3(%rbx),%eax
cmp    $0x1,%eax
ja     2078 <linbcg+0xf08>
mov    %r13,%rdx
xor    %ecx,%ecx
call   1040 <asolve@plt>
mov    (%rsp),%rbp
mov    %rbp,%rdi
mov    %r13,%rsi
mov    %ebx,%edx
call   1050 <snrm@plt>
movsd  %xmm0,0x38(%rsp)
mov    %rbp,%rdi
mov    0x40(%rsp),%rsi
mov    %r13,%rdx
xor    %ecx,%ecx
call   1040 <asolve@plt>
mov    %rbp,%rdi
mov    %r13,%rsi
mov    %ebx,%edx
call   1050 <snrm@plt>
movapd %xmm0,0xa0(%rsp)
jmp    14b2 <linbcg+0x342>
lea    0xfb9(%rip),%rdi
call   1060 <nrerror@plt>
jmp    14b2 <linbcg+0x342>
mov    (%rsp),%rdi
mov    0x18(%rsp),%rsi
jmp    125f <linbcg+0xef>
or     $0x1,%r11
jmp    125f <linbcg+0xef>
mov    $0x1,%ecx
test   $0x1,%dl
jne    1411 <linbcg+0x2a1>
jmp    1449 <linbcg+0x2d9>

LLVM IR (-O0):
@.str = [23 x i8] c"illegal itol in linbcg\00"
@.str.1 = [21 x i8] c"iter=%4d err=%12.6f\0A\00"
define void @linbcg(i64 %0, double* %1, double* %2, i32 %3, double %4, i32 %5, i32* %6, double* %7) {
%9 = alloca i64
%10 = alloca double*
%11 = alloca double*
%12 = alloca i32
%13 = alloca double
%14 = alloca i32
%15 = alloca i32*
%16 = alloca double*
%17 = alloca i64
%18 = alloca double
%19 = alloca double
%20 = alloca double
%21 = alloca double
%22 = alloca double
%23 = alloca double
%24 = alloca double
%25 = alloca double
%26 = alloca double
%27 = alloca double
%28 = alloca double*
%29 = alloca double*
%30 = alloca double*
%31 = alloca double*
%32 = alloca double*
%33 = alloca double*
store i64 %0, i64* %9
store double* %1, double** %10
store double* %2, double** %11
store i32 %3, i32* %12
store double %4, double* %13
store i32 %5, i32* %14
store i32* %6, i32** %15
store double* %7, double** %16
%34 = load i64, i64* %9
%35 = call double* @dvector(i32 1, i64 %34)
store double* %35, double** %28
%36 = load i64, i64* %9
%37 = call double* @dvector(i32 1, i64 %36)
store double* %37, double** %29
%38 = load i64, i64* %9
%39 = call double* @dvector(i32 1, i64 %38)
store double* %39, double** %30
%40 = load i64, i64* %9
%41 = call double* @dvector(i32 1, i64 %40)
store double* %41, double** %31
%42 = load i64, i64* %9
%43 = call double* @dvector(i32 1, i64 %42)
store double* %43, double** %32
%44 = load i64, i64* %9
%45 = call double* @dvector(i32 1, i64 %44)
store double* %45, double** %33
%46 = load i32*, i32** %15
store i32 0, i32* %46
%47 = load i64, i64* %9
%48 = load double*, double** %11
%49 = load double*, double** %30
store i64 1, i64* %17
br label %50
50: ; preds = %74, %8
%51 = load i64, i64* %17
%52 = load i64, i64* %9
%53 = icmp ule i64 %51, %52
br i1 %53, label %54, label %77
54: ; preds = %50
%55 = load double*, double** %10
%56 = load i64, i64* %17
%57 = getelementptr inbounds double, double* %55, i64 %56
%58 = load double, double* %57
%59 = load double*, double** %30
%60 = load i64, i64* %17
%61 = getelementptr inbounds double, double* %59, i64 %60
%62 = load double, double* %61
%63 = fsub double %58, %62
%64 = load double*, double** %30
%65 = load i64, i64* %17
%66 = getelementptr inbounds double, double* %64, i64 %65
store double %63, double* %66
%67 = load double*, double** %30
%68 = load i64, i64* %17
%69 = getelementptr inbounds double, double* %67, i64 %68
%70 = load double, double* %69
%71 = load double*, double** %31
%72 = load i64, i64* %17
%73 = getelementptr inbounds double, double* %71, i64 %72
store double %70, double* %73
br label %74
74: ; preds = %54
%75 = load i64, i64* %17
%76 = add i64 %75, 1
store i64 %76, i64* %17
br label %50
77: ; preds = %50
%78 = load i32, i32* %12
%79 = icmp eq i32 %78, 1
br i1 %79, label %80, label %88
80: ; preds = %77
%81 = load i64, i64* %9
%82 = load double*, double** %10
%83 = load i32, i32* %12
%84 = call double @snrm(i64 %81, double* %82, i32 %83)
store double %84, double* %23
%85 = load i64, i64* %9
%86 = load double*, double** %30
%87 = load double*, double** %32
br label %127
88: ; preds = %77
%89 = load i32, i32* %12
%90 = icmp eq i32 %89, 2
br i1 %90, label %91, label %102
91: ; preds = %88
%92 = load i64, i64* %9
%93 = load double*, double** %10
%94 = load double*, double** %32
%95 = load i64, i64* %9
%96 = load double*, double** %32
%97 = load i32, i32* %12
%98 = call double @snrm(i64 %95, double* %96, i32 %97)
store double %98, double* %23
%99 = load i64, i64* %9
%100 = load double*, double** %30
%101 = load double*, double** %32
br label %126
102: ; preds = %88
%103 = load i32, i32* %12
%104 = icmp eq i32 %103, 3
br i1 %104, label %108, label %105
105: ; preds = %102
%106 = load i32, i32* %12
%107 = icmp eq i32 %106, 4
br i1 %107, label %108, label %123
108: ; preds = %105, %102
%109 = load i64, i64* %9
%110 = load double*, double** %10
%111 = load double*, double** %32
%112 = load i64, i64* %9
%113 = load double*, double** %32
%114 = load i32, i32* %12
%115 = call double @snrm(i64 %112, double* %113, i32 %114)
store double %115, double* %23
%116 = load i64, i64* %9
%117 = load double*, double** %30
%118 = load double*, double** %32
%119 = load i64, i64* %9
%120 = load double*, double** %32
%121 = load i32, i32* %12
%122 = call double @snrm(i64 %119, double* %120, i32 %121)
store double %122, double* %27
br label %125
123: ; preds = %105
%124 = call i32 @nrerror(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str, i64 0, i64 0))
br label %125
125: ; preds = %123, %108
br label %126
126: ; preds = %125, %91
br label %127
127: ; preds = %126, %80
br label %128
128: ; preds = %395, %376, %356, %127
%129 = load i32*, i32** %15
%130 = load i32, i32* %129
%131 = load i32, i32* %14
%132 = icmp sle i32 %130, %131
br i1 %132, label %133, label %396
133: ; preds = %128
%134 = load i32*, i32** %15
%135 = load i32, i32* %134
%136 = add nsw i32 %135, 1
store i32 %136, i32* %134
%137 = load i64, i64* %9
%138 = load double*, double** %31
%139 = load double*, double** %33
store double 0.000000e+00, double* %22
store i64 1, i64* %17
br label %140
140: ; preds = %155, %133
%141 = load i64, i64* %17
%142 = load i64, i64* %9
%143 = icmp ule i64 %141, %142
br i1 %143, label %144, label %158
144: ; preds = %140
%145 = load double*, double** %32
%146 = load i64, i64* %17
%147 = getelementptr inbounds double, double* %145, i64 %146
%148 = load double, double* %147
%149 = load double*, double** %31
%150 = load i64, i64* %17
%151 = getelementptr inbounds double, double* %149, i64 %150
%152 = load double, double* %151
%153 = load double, double* %22
%154 = call double @llvm.fmuladd.f64(double %148, double %152, double %153)
store double %154, double* %22
br label %155
155: ; preds = %144
%156 = load i64, i64* %17
%157 = add i64 %156, 1
store i64 %157, i64* %17
br label %140
158: ; preds = %140
%159 = load i32*, i32** %15
%160 = load i32, i32* %159
%161 = icmp eq i32 %160, 1
br i1 %161, label %162, label %186
162: ; preds = %158
store i64 1, i64* %17
br label %163
163: ; preds = %182, %162
%164 = load i64, i64* %17
%165 = load i64, i64* %9
%166 = icmp ule i64 %164, %165
br i1 %166, label %167, label %185
167: ; preds = %163
%168 = load double*, double** %32
%169 = load i64, i64* %17
%170 = getelementptr inbounds double, double* %168, i64 %169
%171 = load double, double* %170
%172 = load double*, double** %28
%173 = load i64, i64* %17
%174 = getelementptr inbounds double, double* %172, i64 %173
store double %171, double* %174
%175 = load double*, double** %33
%176 = load i64, i64* %17
%177 = getelementptr inbounds double, double* %175, i64 %176
%178 = load double, double* %177
%179 = load double*, double** %29
%180 = load i64, i64* %17
%181 = getelementptr inbounds double, double* %179, i64 %180
store double %178, double* %181
br label %182
182: ; preds = %167
%183 = load i64, i64* %17
%184 = add i64 %183, 1
store i64 %184, i64* %17
br label %163
185: ; preds = %163
br label %225
186: ; preds = %158
%187 = load double, double* %22
%188 = load double, double* %21
%189 = fdiv double %187, %188
store double %189, double* %20
store i64 1, i64* %17
br label %190
190: ; preds = %221, %186
%191 = load i64, i64* %17
%192 = load i64, i64* %9
%193 = icmp ule i64 %191, %192
br i1 %193, label %194, label %224
194: ; preds = %190
%195 = load double, double* %20
%196 = load double*, double** %28
%197 = load i64, i64* %17
%198 = getelementptr inbounds double, double* %196, i64 %197
%199 = load double, double* %198
%200 = load double*, double** %32
%201 = load i64, i64* %17
%202 = getelementptr inbounds double, double* %200, i64 %201
%203 = load double, double* %202
%204 = call double @llvm.fmuladd.f64(double %195, double %199, double %203)
%205 = load double*, double** %28
%206 = load i64, i64* %17
%207 = getelementptr inbounds double, double* %205, i64 %206
store double %204, double* %207
%208 = load double, double* %20
%209 = load double*, double** %29
%210 = load i64, i64* %17
%211 = getelementptr inbounds double, double* %209, i64 %210
%212 = load double, double* %211
%213 = load double*, double** %33
%214 = load i64, i64* %17
%215 = getelementptr inbounds double, double* %213, i64 %214
%216 = load double, double* %215
%217 = call double @llvm.fmuladd.f64(double %208, double %212, double %216)
%218 = load double*, double** %29
%219 = load i64, i64* %17
%220 = getelementptr inbounds double, double* %218, i64 %219
store double %217, double* %220
br label %221
221: ; preds = %194
%222 = load i64, i64* %17
%223 = add i64 %222, 1
store i64 %223, i64* %17
br label %190
224: ; preds = %190
br label %225
225: ; preds = %224, %185
%226 = load double, double* %22
store double %226, double* %21
%227 = load i64, i64* %9
%228 = load double*, double** %28
%229 = load double*, double** %32
store double 0.000000e+00, double* %19
store i64 1, i64* %17
br label %230
230: ; preds = %245, %225
%231 = load i64, i64* %17
%232 = load i64, i64* %9
%233 = icmp ule i64 %231, %232
br i1 %233, label %234, label %248
234: ; preds = %230
%235 = load double*, double** %32
%236 = load i64, i64* %17
%237 = getelementptr inbounds double, double* %235, i64 %236
%238 = load double, double* %237
%239 = load double*, double** %29
%240 = load i64, i64* %17
%241 = getelementptr inbounds double, double* %239, i64 %240
%242 = load double, double* %241
%243 = load double, double* %19
%244 = call double @llvm.fmuladd.f64(double %238, double %242, double %243)
store double %244, double* %19
br label %245
245: ; preds = %234
%246 = load i64, i64* %17
%247 = add i64 %246, 1
store i64 %247, i64* %17
br label %230
248: ; preds = %230
%249 = load double, double* %22
%250 = load double, double* %19
%251 = fdiv double %249, %250
store double %251, double* %18
%252 = load i64, i64* %9
%253 = load double*, double** %29
%254 = load double*, double** %33
store i64 1, i64* %17
br label %255
255: ; preds = %292, %248
%256 = load i64, i64* %17
%257 = load i64, i64* %9
%258 = icmp ule i64 %256, %257
br i1 %258, label %259, label %295
259: ; preds = %255
%260 = load double, double* %18
%261 = load double*, double** %28
%262 = load i64, i64* %17
%263 = getelementptr inbounds double, double* %261, i64 %262
%264 = load double, double* %263
%265 = load double*, double** %11
%266 = load i64, i64* %17
%267 = getelementptr inbounds double, double* %265, i64 %266
%268 = load double, double* %267
%269 = call double @llvm.fmuladd.f64(double %260, double %264, double %268)
store double %269, double* %267
%270 = load double, double* %18
%271 = load double*, double** %32
%272 = load i64, i64* %17
%273 = getelementptr inbounds double, double* %271, i64 %272
%274 = load double, double* %273
%275 = load double*, double** %30
%276 = load i64, i64* %17
%277 = getelementptr inbounds double, double* %275, i64 %276
%278 = load double, double* %277
%279 = fneg double %270
%280 = call double @llvm.fmuladd.f64(double %279, double %274, double %278)
store double %280, double* %277
%281 = load double, double* %18
%282 = load double*, double** %33
%283 = load i64, i64* %17
%284 = getelementptr inbounds double, double* %282, i64 %283
%285 = load double, double* %284
%286 = load double*, double** %31
%287 = load i64, i64* %17
%288 = getelementptr inbounds double, double* %286, i64 %287
%289 = load double, double* %288
%290 = fneg double %281
%291 = call double @llvm.fmuladd.f64(double %290, double %285, double %289)
store double %291, double* %288
br label %292
292: ; preds = %259
%293 = load i64, i64* %17
%294 = add i64 %293, 1
store i64 %294, i64* %17
br label %255
295: ; preds = %255
%296 = load i64, i64* %9
%297 = load double*, double** %30
%298 = load double*, double** %32
%299 = load i32, i32* %12
%300 = icmp eq i32 %299, 1
br i1 %300, label %301, label %309
301: ; preds = %295
%302 = load i64, i64* %9
%303 = load double*, double** %30
%304 = load i32, i32* %12
%305 = call double @snrm(i64 %302, double* %303, i32 %304)
%306 = load double, double* %23
%307 = fdiv double %305, %306
%308 = load double*, double** %16
store double %307, double* %308
br label %384
309: ; preds = %295
%310 = load i32, i32* %12
%311 = icmp eq i32 %310, 2
br i1 %311, label %312, label %320
312: ; preds = %309
%313 = load i64, i64* %9
%314 = load double*, double** %32
%315 = load i32, i32* %12
%316 = call double @snrm(i64 %313, double* %314, i32 %315)
%317 = load double, double* %23
%318 = fdiv double %316, %317
%319 = load double*, double** %16
store double %318, double* %319
br label %383
320: ; preds = %309
%321 = load i32, i32* %12
%322 = icmp eq i32 %321, 3
br i1 %322, label %326, label %323
323: ; preds = %320
%324 = load i32, i32* %12
%325 = icmp eq i32 %324, 4
br i1 %325, label %326, label %382
326: ; preds = %323, %320
%327 = load double, double* %27
store double %327, double* %26
%328 = load i64, i64* %9
%329 = load double*, double** %32
%330 = load i32, i32* %12
%331 = call double @snrm(i64 %328, double* %329, i32 %330)
store double %331, double* %27
%332 = load double, double* %26
%333 = load double, double* %27
%334 = fsub double %332, %333
%335 = call double @llvm.fabs.f64(double %334)
%336 = load double, double* %27
%337 = fmul double 0x3D06849B86A12B9B, %336
%338 = fcmp ogt double %335, %337
br i1 %338, label %339, label %356
339: ; preds = %326
%340 = load double, double* %18
%341 = call double @llvm.fabs.f64(double %340)
%342 = load i64, i64* %9
%343 = load double*, double** %28
%344 = load i32, i32* %12
%345 = call double @snrm(i64 %342, double* %343, i32 %344)
%346 = fmul double %341, %345
store double %346, double* %24
%347 = load double, double* %27
%348 = load double, double* %26
%349 = load double, double* %27
%350 = fsub double %348, %349
%351 = call double @llvm.fabs.f64(double %350)
%352 = fdiv double %347, %351
%353 = load double, double* %24
%354 = fmul double %352, %353
%355 = load double*, double** %16
store double %354, double* %355
br label %361
356: ; preds = %326
%357 = load double, double* %27
%358 = load double, double* %23
%359 = fdiv double %357, %358
%360 = load double*, double** %16
store double %359, double* %360
br label %128
361: ; preds = %339
%362 = load i64, i64* %9
%363 = load double*, double** %11
%364 = load i32, i32* %12
%365 = call double @snrm(i64 %362, double* %363, i32 %364)
store double %365, double* %25
%366 = load double*, double** %16
%367 = load double, double* %366
%368 = load double, double* %25
%369 = fmul double 5.000000e-01, %368
%370 = fcmp ole double %367, %369
br i1 %370, label %371, label %376
371: ; preds = %361
%372 = load double, double* %25
%373 = load double*, double** %16
%374 = load double, double* %373
%375 = fdiv double %374, %372
store double %375, double* %373
br label %381
376: ; preds = %361
%377 = load double, double* %27
%378 = load double, double* %23
%379 = fdiv double %377, %378
%380 = load double*, double** %16
store double %379, double* %380
br label %128
381: ; preds = %371
br label %382
382: ; preds = %381, %323
br label %383
383: ; preds = %382, %312
br label %384
384: ; preds = %383, %301
%385 = load i32*, i32** %15
%386 = load i32, i32* %385
%387 = load double*, double** %16
%388 = load double, double* %387
%389 = call i32 @printf(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.1, i64 0, i64 0), i32 %386, double %388)
%390 = load double*, double** %16
%391 = load double, double* %390
%392 = load double, double* %13
%393 = fcmp ole double %391, %392
br i1 %393, label %394, label %395
394: ; preds = %384
br label %396
395: ; preds = %384
br label %128
396: ; preds = %394, %128
%397 = load double*, double** %28
%398 = load i64, i64* %9
%399 = call i32 @free_dvector(double* %397, i32 1, i64 %398)
%400 = load double*, double** %29
%401 = load i64, i64* %9
%402 = call i32 @free_dvector(double* %400, i32 1, i64 %401)
%403 = load double*, double** %30
%404 = load i64, i64* %9
%405 = call i32 @free_dvector(double* %403, i32 1, i64 %404)
%406 = load double*, double** %31
%407 = load i64, i64* %9
%408 = call i32 @free_dvector(double* %406, i32 1, i64 %407)
%409 = load double*, double** %32
%410 = load i64, i64* %9
%411 = call i32 @free_dvector(double* %409, i32 1, i64 %410)
%412 = load double*, double** %33
%413 = load i64, i64* %9
%414 = call i32 @free_dvector(double* %412, i32 1, i64 %413)
ret void
}

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