int update_(long int *n, long int *npt, double *bmat, double *zmat,
            long int *idz, long int *ndim, double *vlag, double *beta,
            long int *knew, double *w) {
  long int bmat_dim1, bmat_offset, zmat_dim1, zmat_offset, i__1, i__2;
  double d__1, d__2;
  double sqrt(double);
  static long int i__, j, ja, jb, jl, jp;
  static double one, tau, temp;
  static long int nptm;
  static double zero;
  static long int iflag;
  static double scala, scalb, alpha, denom, tempa, tempb, tausq;
  zmat_dim1 = *npt;
  zmat_offset = 1 + zmat_dim1;
  zmat -= zmat_offset;
  bmat_dim1 = *ndim;
  bmat_offset = 1 + bmat_dim1;
  bmat -= bmat_offset;
  --vlag;
  --w;
  one = 1.;
  zero = 0.;
  nptm = *npt - *n - 1;
  jl = 1;
  i__1 = nptm;
  for (j = 2; j <= i__1; ++j) {
    if (j == *idz) {
      jl = *idz;
    } else if (zmat[*knew + j * zmat_dim1] != zero) {
      d__1 = zmat[*knew + jl * zmat_dim1];
      d__2 = zmat[*knew + j * zmat_dim1];
      temp = sqrt(d__1 * d__1 + d__2 * d__2);
      tempa = zmat[*knew + jl * zmat_dim1] / temp;
      tempb = zmat[*knew + j * zmat_dim1] / temp;
      i__2 = *npt;
      for (i__ = 1; i__ <= i__2; ++i__) {
        temp = tempa * zmat[i__ + jl * zmat_dim1] +
               tempb * zmat[i__ + j * zmat_dim1];
        zmat[i__ + j * zmat_dim1] = tempa * zmat[i__ + j * zmat_dim1] -
                                    tempb * zmat[i__ + jl * zmat_dim1];
        zmat[i__ + jl * zmat_dim1] = temp;
      }
      zmat[*knew + j * zmat_dim1] = zero;
    }
  }
  tempa = zmat[*knew + zmat_dim1];
  if (*idz >= 2) {
    tempa = -tempa;
  }
  if (jl > 1) {
    tempb = zmat[*knew + jl * zmat_dim1];
  }
  i__1 = *npt;
  for (i__ = 1; i__ <= i__1; ++i__) {
    w[i__] = tempa * zmat[i__ + zmat_dim1];
    if (jl > 1) {
      w[i__] += tempb * zmat[i__ + jl * zmat_dim1];
    }
  }
  alpha = w[*knew];
  tau = vlag[*knew];
  tausq = tau * tau;
  denom = alpha * *beta + tausq;
  vlag[*knew] -= one;
  iflag = 0;
  if (jl == 1) {
    temp = sqrt((abs(denom)));
    tempb = tempa / temp;
    tempa = tau / temp;
    i__1 = *npt;
    for (i__ = 1; i__ <= i__1; ++i__) {
      zmat[i__ + zmat_dim1] = tempa * zmat[i__ + zmat_dim1] - tempb * vlag[i__];
    }
    if (*idz == 1 && temp < zero) {
      *idz = 2;
    }
    if (*idz >= 2 && temp >= zero) {
      iflag = 1;
    }
  } else {
    ja = 1;
    if (*beta >= zero) {
      ja = jl;
    }
    jb = jl + 1 - ja;
    temp = zmat[*knew + jb * zmat_dim1] / denom;
    tempa = temp * *beta;
    tempb = temp * tau;
    temp = zmat[*knew + ja * zmat_dim1];
    scala = one / sqrt(abs(*beta) * temp * temp + tausq);
    scalb = scala * sqrt((abs(denom)));
    i__1 = *npt;
    for (i__ = 1; i__ <= i__1; ++i__) {
      zmat[i__ + ja * zmat_dim1] =
          scala * (tau * zmat[i__ + ja * zmat_dim1] - temp * vlag[i__]);
      zmat[i__ + jb * zmat_dim1] = scalb * (zmat[i__ + jb * zmat_dim1] -
                                            tempa * w[i__] - tempb * vlag[i__]);
    }
    if (denom <= zero) {
      if (*beta < zero) {
        ++(*idz);
      }
      if (*beta >= zero) {
        iflag = 1;
      }
    }
  }
  if (iflag == 1) {
    --(*idz);
    i__1 = *npt;
    for (i__ = 1; i__ <= i__1; ++i__) {
      temp = zmat[i__ + zmat_dim1];
      zmat[i__ + zmat_dim1] = zmat[i__ + *idz * zmat_dim1];
      zmat[i__ + *idz * zmat_dim1] = temp;
    }
  }
  i__1 = *n;
  for (j = 1; j <= i__1; ++j) {
    jp = *npt + j;
    w[jp] = bmat[*knew + j * bmat_dim1];
    tempa = (alpha * vlag[jp] - tau * w[jp]) / denom;
    tempb = (-(*beta) * w[jp] - tau * vlag[jp]) / denom;
    i__2 = jp;
    for (i__ = 1; i__ <= i__2; ++i__) {
      bmat[i__ + j * bmat_dim1] =
          bmat[i__ + j * bmat_dim1] + tempa * vlag[i__] + tempb * w[i__];
      if (i__ > *npt) {
        bmat[jp + (i__ - *npt) * bmat_dim1] = bmat[i__ + j * bmat_dim1];
      }
    }
  }
  return 0;
}


x86 assembly (clang, -O0):
<update_>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rdx
mov    -0x20(%rbp),%rax
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x30(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rdx
mov    -0x18(%rbp),%rax
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    0x10(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x10(%rbp)
mov    0x28(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x28(%rbp)
movsd  0xe2f(%rip),%xmm0
movsd  %xmm0,0x2e8f(%rip)
xorps  %xmm0,%xmm0
movsd  %xmm0,0x2ea4(%rip)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    -0x8(%rbp),%rcx
sub    (%rcx),%rax
sub    $0x1,%rax
mov    %rax,0x2e83(%rip)
movq   $0x1,0x2e50(%rip)
mov    0x2e71(%rip),%rax
mov    %rax,-0x58(%rbp)
movq   $0x2,0x2e22(%rip)
mov    0x2e1b(%rip),%rax
cmp    -0x58(%rbp),%rax
jg     14f4 <update_+0x3d4>
mov    0x2e0a(%rip),%rax
mov    -0x28(%rbp),%rcx
cmp    (%rcx),%rax
jne    1256 <update_+0x136>
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
mov    %rax,0x2e07(%rip)
jmp    14d8 <update_+0x3b8>
mov    -0x20(%rbp),%rax
mov    0x20(%rbp),%rcx
mov    (%rcx),%rcx
mov    0x2dd8(%rip),%rdx
imul   -0x48(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd 0x2e0b(%rip),%xmm0
jne    128e <update_+0x16e>
jp     128e <update_+0x16e>
jmp    14d3 <update_+0x3b3>
mov    -0x20(%rbp),%rax
mov    0x20(%rbp),%rcx
mov    (%rcx),%rcx
mov    0x2db8(%rip),%rdx
imul   -0x48(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x20(%rbp),%rax
mov    0x20(%rbp),%rcx
mov    (%rcx),%rcx
mov    0x2d7c(%rip),%rdx
imul   -0x48(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x68(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1040 <sqrt@plt>
movsd  %xmm0,0x2d79(%rip)
mov    -0x20(%rbp),%rax
mov    0x20(%rbp),%rcx
mov    (%rcx),%rcx
mov    0x2d47(%rip),%rdx
imul   -0x48(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  0x2d52(%rip),%xmm0
movsd  %xmm0,0x2d8a(%rip)
mov    -0x20(%rbp),%rax
mov    0x20(%rbp),%rcx
mov    (%rcx),%rcx
mov    0x2d00(%rip),%rdx
imul   -0x48(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  0x2d23(%rip),%xmm0
movsd  %xmm0,0x2d63(%rip)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x60(%rbp)
movq   $0x1,0x2cc5(%rip)
mov    0x2cbe(%rip),%rax
cmp    -0x60(%rbp),%rax
jg     14ac <update_+0x38c>
movsd  0x2d2c(%rip),%xmm0
mov    -0x20(%rbp),%rax
mov    0x2ca1(%rip),%rcx
mov    0x2cba(%rip),%rdx
imul   -0x48(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x2d0d(%rip),%xmm1
mov    -0x20(%rbp),%rax
mov    0x2c7a(%rip),%rcx
mov    0x2c7b(%rip),%rdx
imul   -0x48(%rbp),%rdx
add    %rdx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x2c96(%rip)
movsd  0x2cce(%rip),%xmm0
mov    -0x20(%rbp),%rax
mov    0x2c43(%rip),%rcx
mov    0x2c44(%rip),%rdx
imul   -0x48(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x2caf(%rip),%xmm1
mov    -0x20(%rbp),%rax
mov    0x2c1c(%rip),%rcx
mov    0x2c35(%rip),%rdx
imul   -0x48(%rbp),%rdx
add    %rdx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    0x2bde(%rip),%rcx
mov    0x2bdf(%rip),%rdx
imul   -0x48(%rbp),%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x2c02(%rip),%xmm0
mov    -0x20(%rbp),%rax
mov    0x2bb7(%rip),%rcx
mov    0x2bd0(%rip),%rdx
imul   -0x48(%rbp),%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x2b9c(%rip),%rax
add    $0x1,%rax
mov    %rax,0x2b91(%rip)
jmp    1373 <update_+0x253>
movsd  0x2bd4(%rip),%xmm0
mov    -0x20(%rbp),%rax
mov    0x20(%rbp),%rcx
mov    (%rcx),%rcx
mov    0x2b7a(%rip),%rdx
imul   -0x48(%rbp),%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    14d8 <update_+0x3b8>
jmp    14dd <update_+0x3bd>
mov    0x2b5c(%rip),%rax
add    $0x1,%rax
mov    %rax,0x2b51(%rip)
jmp    121e <update_+0xfe>
mov    -0x20(%rbp),%rax
mov    0x20(%rbp),%rcx
mov    (%rcx),%rcx
add    -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x2ba8(%rip)
mov    -0x28(%rbp),%rax
cmpq   $0x2,(%rax)
jl     1545 <update_+0x425>
movsd  0x2b92(%rip),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,0x2b73(%rip)
cmpq   $0x1,0x2b0b(%rip)
01
jle    157a <update_+0x45a>
mov    -0x20(%rbp),%rax
mov    0x20(%rbp),%rcx
mov    (%rcx),%rcx
mov    0x2af3(%rip),%rdx
imul   -0x48(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x2b46(%rip)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x58(%rbp)
movq   $0x1,0x2aa8(%rip)
mov    0x2aa1(%rip),%rax
cmp    -0x58(%rbp),%rax
jg     163b <update_+0x51b>
movsd  0x2b0f(%rip),%xmm0
mov    -0x20(%rbp),%rax
mov    0x2a84(%rip),%rcx
add    -0x48(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    0x2a70(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
cmpq   $0x1,0x2a83(%rip)
01
jle    161f <update_+0x4ff>
movsd  0x2add(%rip),%xmm0
mov    -0x20(%rbp),%rax
mov    0x2a4a(%rip),%rcx
mov    0x2a63(%rip),%rdx
imul   -0x48(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x28(%rbp),%rax
mov    0x2a2b(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1624 <update_+0x504>
mov    0x2a0d(%rip),%rax
add    $0x1,%rax
mov    %rax,0x2a02(%rip)
jmp    1590 <update_+0x470>
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rcx
mov    (%rcx),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x2a55(%rip)
mov    0x10(%rbp),%rax
mov    0x20(%rbp),%rcx
mov    (%rcx),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x2a05(%rip)
movsd  0x29fd(%rip),%xmm0
mulsd  0x29f5(%rip),%xmm0
movsd  %xmm0,0x2a45(%rip)
movsd  0x2a1d(%rip),%xmm0
mov    0x18(%rbp),%rax
movsd  (%rax),%xmm2
movsd  0x2a2d(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x2a05(%rip)
movsd  0x29b5(%rip),%xmm1
mov    0x10(%rbp),%rax
mov    0x20(%rbp),%rcx
mov    (%rcx),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movq   $0x0,0x29b9(%rip)
cmpq   $0x1,0x2979(%rip)
01
jne    183f <update_+0x71f>
cvttsd2si 0x29c3(%rip),%edi
call   1030 <abs@plt>
cvtsi2sd %eax,%xmm0
call   1040 <sqrt@plt>
movsd  %xmm0,0x2975(%rip)
movsd  0x29ad(%rip),%xmm0
divsd  0x2965(%rip),%xmm0
movsd  %xmm0,0x29a5(%rip)
movsd  0x294d(%rip),%xmm0
divsd  0x294d(%rip),%xmm0
movsd  %xmm0,0x2985(%rip)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x58(%rbp)
movq   $0x1,0x28ef(%rip)
mov    0x28e8(%rip),%rax
cmp    -0x58(%rbp),%rax
jg     17d8 <update_+0x6b8>
movsd  0x2956(%rip),%xmm0
mov    -0x20(%rbp),%rax
mov    0x28cb(%rip),%rcx
add    -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x2942(%rip),%xmm1
mov    0x10(%rbp),%rax
mov    0x28af(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    0x2880(%rip),%rcx
add    -0x48(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x2870(%rip),%rax
add    $0x1,%rax
mov    %rax,0x2865(%rip)
jmp    1749 <update_+0x629>
mov    -0x28(%rbp),%rax
cmpq   $0x1,(%rax)
jne    180b <update_+0x6eb>
movsd  0x288a(%rip),%xmm1
movsd  0x2892(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    180b <update_+0x6eb>
mov    -0x28(%rbp),%rax
movq   $0x2,(%rax)
mov    -0x28(%rbp),%rax
cmpq   $0x2,(%rax)
jl     183a <update_+0x71a>
movsd  0x2857(%rip),%xmm0
ucomisd 0x285f(%rip),%xmm0
jb     183a <update_+0x71a>
movq   $0x1,0x2856(%rip)
jmp    1b87 <update_+0xa67>
movq   $0x1,0x27fe(%rip)
mov    0x18(%rbp),%rax
movsd  (%rax),%xmm0
ucomisd 0x282e(%rip),%xmm0
jb     186e <update_+0x74e>
mov    0x27f1(%rip),%rax
mov    %rax,0x27da(%rip)
mov    0x27e3(%rip),%rax
add    $0x1,%rax
sub    0x27c8(%rip),%rax
mov    %rax,0x27c9(%rip)
mov    -0x20(%rbp),%rax
mov    0x20(%rbp),%rcx
mov    (%rcx),%rcx
mov    0x27b7(%rip),%rdx
imul   -0x48(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  0x2802(%rip),%xmm0
movsd  %xmm0,0x27c2(%rip)
movsd  0x27ba(%rip),%xmm0
mov    0x18(%rbp),%rax
mulsd  (%rax),%xmm0
movsd  %xmm0,0x27ea(%rip)
movsd  0x27a2(%rip),%xmm0
mulsd  0x2792(%rip),%xmm0
movsd  %xmm0,0x27da(%rip)
mov    -0x20(%rbp),%rax
mov    0x20(%rbp),%rcx
mov    (%rcx),%rcx
mov    0x2750(%rip),%rdx
imul   -0x48(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x276b(%rip)
movsd  0x2753(%rip),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    0x18(%rbp),%rax
cvttsd2si (%rax),%edi
call   1030 <abs@plt>
cvtsi2sd %eax,%xmm0
mulsd  0x2745(%rip),%xmm0
movsd  0x273d(%rip),%xmm2
movsd  0x2785(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1040 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0x80(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x2734(%rip)
movsd  0x272c(%rip),%xmm0
movsd  %xmm0,-0x78(%rbp)
cvttsd2si 0x2737(%rip),%edi
call   1030 <abs@plt>
cvtsi2sd %eax,%xmm0
call   1040 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0x78(%rbp),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x2705(%rip)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x58(%rbp)
movq   $0x1,0x2687(%rip)
mov    0x2680(%rip),%rax
cmp    -0x58(%rbp),%rax
jg     1b1a <update_+0x9fa>
movsd  0x26ce(%rip),%xmm0
movsd  0x269e(%rip),%xmm1
mov    -0x20(%rbp),%rax
mov    0x265b(%rip),%rcx
mov    0x2664(%rip),%rdx
imul   -0x48(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm3
movsd  0x267f(%rip),%xmm2
mov    0x10(%rbp),%rax
mov    0x2634(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm2
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    0x2601(%rip),%rcx
mov    0x260a(%rip),%rdx
imul   -0x48(%rbp),%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x264d(%rip),%xmm0
mov    -0x20(%rbp),%rax
mov    0x25da(%rip),%rcx
mov    0x25eb(%rip),%rdx
imul   -0x48(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0x263e(%rip),%xmm2
mov    0x28(%rbp),%rax
mov    0x25b3(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm3
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  0x260f(%rip),%xmm1
mov    0x10(%rbp),%rax
mov    0x257c(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm3
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    0x2549(%rip),%rcx
mov    0x255a(%rip),%rdx
imul   -0x48(%rbp),%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x252e(%rip),%rax
add    $0x1,%rax
mov    %rax,0x2523(%rip)
jmp    19b1 <update_+0x891>
movsd  0x258e(%rip),%xmm1
movsd  0x255e(%rip),%xmm0
ucomisd %xmm1,%xmm0
jb     1b82 <update_+0xa62>
mov    0x18(%rbp),%rax
movsd  (%rax),%xmm1
movsd  0x2544(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1b5c <update_+0xa3c>
mov    -0x28(%rbp),%rax
mov    (%rax),%rcx
add    $0x1,%rcx
mov    %rcx,(%rax)
mov    0x18(%rbp),%rax
movsd  (%rax),%xmm0
ucomisd 0x251c(%rip),%xmm0
jb     1b7d <update_+0xa5d>
movq   $0x1,0x2513(%rip)
jmp    1b82 <update_+0xa62>
jmp    1b87 <update_+0xa67>
cmpq   $0x1,0x2501(%rip)
01
jne    1c5c <update_+0xb3c>
mov    -0x28(%rbp),%rax
mov    (%rax),%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,(%rax)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x58(%rbp)
movq   $0x1,0x247f(%rip)
mov    0x2478(%rip),%rax
cmp    -0x58(%rbp),%rax
jg     1c57 <update_+0xb37>
mov    -0x20(%rbp),%rax
mov    0x2463(%rip),%rcx
add    -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x2492(%rip)
mov    -0x20(%rbp),%rax
mov    0x2447(%rip),%rcx
mov    -0x28(%rbp),%rdx
mov    (%rdx),%rdx
imul   -0x48(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    0x2428(%rip),%rcx
add    -0x48(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x2457(%rip),%xmm0
mov    -0x20(%rbp),%rax
mov    0x240c(%rip),%rcx
mov    -0x28(%rbp),%rdx
mov    (%rdx),%rdx
imul   -0x48(%rbp),%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x23f1(%rip),%rax
add    $0x1,%rax
mov    %rax,0x23e6(%rip)
jmp    1bb9 <update_+0xa99>
jmp    1c5c <update_+0xb3c>
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x58(%rbp)
movq   $0x1,0x23ce(%rip)
mov    0x23c7(%rip),%rax
cmp    -0x58(%rbp),%rax
jg     1ed2 <update_+0xdb2>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
add    0x23af(%rip),%rax
mov    %rax,0x23c8(%rip)
mov    -0x18(%rbp),%rax
mov    0x20(%rbp),%rcx
mov    (%rcx),%rcx
mov    0x2396(%rip),%rdx
imul   -0x38(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    0x239e(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x23d9(%rip),%xmm0
mov    0x10(%rbp),%rax
mov    0x2386(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x2389(%rip),%xmm1
mov    0x28(%rbp),%rax
mov    0x236e(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  0x2392(%rip),%xmm0
movsd  %xmm0,0x2392(%rip)
mov    0x18(%rbp),%rax
movsd  (%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    0x28(%rbp),%rax
mov    0x2310(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x2313(%rip),%xmm1
mov    0x10(%rbp),%rax
mov    0x22f8(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  0x231c(%rip),%xmm0
movsd  %xmm0,0x2324(%rip)
mov    0x22bd(%rip),%rax
mov    %rax,-0x60(%rbp)
movq   $0x1,0x2286(%rip)
mov    0x227f(%rip),%rax
cmp    -0x60(%rbp),%rax
jg     1eb6 <update_+0xd96>
mov    -0x18(%rbp),%rax
mov    0x226a(%rip),%rcx
mov    0x226b(%rip),%rdx
imul   -0x38(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x22ce(%rip),%xmm1
mov    0x10(%rbp),%rax
mov    0x2243(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x22b6(%rip),%xmm0
mov    0x28(%rbp),%rax
mov    0x2223(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    0x220b(%rip),%rcx
mov    0x220c(%rip),%rdx
imul   -0x38(%rbp),%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x21f0(%rip),%rax
mov    -0x10(%rbp),%rcx
cmp    (%rcx),%rax
jle    1e9a <update_+0xd7a>
mov    -0x18(%rbp),%rax
mov    0x21d8(%rip),%rcx
mov    0x21d9(%rip),%rdx
imul   -0x38(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    0x21e1(%rip),%rcx
mov    0x21b2(%rip),%rdx
mov    -0x10(%rbp),%rsi
sub    (%rsi),%rdx
imul   -0x38(%rbp),%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1e9f <update_+0xd7f>
mov    0x2192(%rip),%rax
add    $0x1,%rax
mov    %rax,0x2187(%rip)
jmp    1db2 <update_+0xc92>
jmp    1ebb <update_+0xd9b>
mov    0x217e(%rip),%rax
add    $0x1,%rax
mov    %rax,0x2173(%rip)
jmp    1c72 <update_+0xb52>
xor    %eax,%eax
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<update_>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xa8,%rsp
mov    %rcx,%r14
mov    %rdx,0x78(%rsp)
mov    0xf0(%rsp),%rbp
mov    (%rsi),%r12
mov    %r12,%rax
not    %rax
lea    (%rcx,%rax,8),%r13
mov    (%r9),%rax
mov    %rax,0x28(%rsp)
movabs $0x3ff0000000000000,%rax
mov    %rax,0x3ef9(%rip)
mov    %rdi,0x70(%rsp)
mov    (%rdi),%r15
not    %r15
add    %r12,%r15
movq   $0x1,0x3ed8(%rip)
movq   $0x2,0x3eb5(%rip)
mov    $0x1,%r9d
mov    %r12,%rcx
cmp    $0x2,%r15
mov    %r8,0x10(%rsp)
jge    12eb <update_+0x1db>
mov    0x0(%rbp),%rdx
lea    (%rdx,%r12,1),%rax
movsd  0x0(%r13,%rax,8),%xmm0
movsd  %xmm0,0x3ede(%rip)
cmpq   $0x2,(%r8)
jl     11c0 <update_+0xb0>
xorpd  0x1e48(%rip),%xmm0
movlpd %xmm0,0x3ec8(%rip)
cmp    $0x2,%r9
jl     11df <update_+0xcf>
mov    %r9,%rax
imul   %r12,%rax
add    %rdx,%rax
movsd  0x0(%r13,%rax,8),%xmm1
movsd  %xmm1,0x3eb1(%rip)
mov    0xe0(%rsp),%r15
test   %rcx,%rcx
jle    1253 <update_+0x143>
movsd  0x3e9c(%rip),%xmm1
lea    -0x8(,%r9,8),%rbp
ff
imul   %r12,%rbp
add    %r14,%rbp
xor    %edi,%edi
jmp    1219 <update_+0x109>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rdi
cmp    %rdi,%rcx
je     1253 <update_+0x143>
movsd  (%r14,%rdi,8),%xmm2
mulsd  %xmm0,%xmm2
mov    0xf8(%rsp),%rax
movsd  %xmm2,(%rax,%rdi,8)
cmp    $0x2,%r9
jl     1210 <update_+0x100>
movsd  0x0(%rbp,%rdi,8),%xmm3
mulsd  %xmm1,%xmm3
addsd  %xmm2,%xmm3
mov    0xf8(%rsp),%rax
movsd  %xmm3,(%rax,%rdi,8)
jmp    1210 <update_+0x100>
mov    0xf8(%rsp),%rax
movsd  -0x8(%rax,%rdx,8),%xmm3
movsd  %xmm3,0x3e0f(%rip)
movsd  -0x8(%r15,%rdx,8),%xmm0
movsd  %xmm0,0x3de0(%rip)
movapd %xmm0,%xmm1
mov    0xe8(%rsp),%rax
mulsd  (%rax),%xmm3
mulsd  %xmm0,%xmm1
addsd  %xmm1,%xmm3
movsd  %xmm3,0x3de8(%rip)
movsd  0x3daf(%rip),%xmm13
movapd %xmm0,%xmm2
subsd  %xmm13,%xmm2
movsd  %xmm2,-0x8(%r15,%rdx,8)
movb   $0x0,0x3db0(%rip)
cmp    $0x1,%r9
jne    1522 <update_+0x412>
cvttsd2si %xmm3,%eax
mov    %eax,%ecx
neg    %ecx
cmovs  %eax,%ecx
xorps  %xmm0,%xmm0
cvtsi2sd %ecx,%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     15cc <update_+0x4bc>
sqrtsd %xmm0,%xmm0
jmp    15dc <update_+0x4cc>
mov    $0x2,%edx
mov    $0x1,%r9d
xorpd  %xmm10,%xmm10
mov    %r12,%rcx
jmp    1321 <update_+0x211>
mov    %rdx,0x3d41(%rip)
mov    %rdx,%r9
lea    0x1(%rdx),%rax
mov    %rax,0x3d1b(%rip)
cmp    %r15,%rdx
mov    %rax,%rdx
jge    1193 <update_+0x83>
cmp    (%r8),%rdx
je     1300 <update_+0x1f0>
mov    0x0(%rbp),%rax
mov    %rdx,%rdi
imul   %r12,%rdi
add    %rax,%rdi
movsd  0x0(%r13,%rdi,8),%xmm1
ucomisd %xmm10,%xmm1
jne    1344 <update_+0x234>
jnp    130a <update_+0x1fa>
imul   %r12,%r9
add    %rax,%r9
movsd  0x0(%r13,%r9,8),%xmm0
mulsd  %xmm1,%xmm1
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
ucomisd %xmm10,%xmm0
jb     136b <update_+0x25b>
sqrtsd %xmm0,%xmm0
jmp    137b <update_+0x26b>
mov    %rsi,%rbx
call   1030 <sqrt@plt>
xorpd  %xmm10,%xmm10
mov    %rbx,%rsi
mov    0x0(%rbp),%rax
mov    0x3cc2(%rip),%r9
mov    %r9,%rcx
imul   %r12,%rcx
add    %rax,%rcx
movsd  0x0(%r13,%rcx,8),%xmm1
mov    0x3c92(%rip),%rdx
mov    %rdx,%r8
imul   %r12,%r8
add    %rax,%r8
movsd  0x0(%r13,%r8,8),%xmm2
divsd  %xmm0,%xmm2
movsd  %xmm2,0x3cd5(%rip)
mov    (%rsi),%rcx
test   %rcx,%rcx
jle    150f <update_+0x3ff>
divsd  %xmm0,%xmm1
movapd %xmm2,%xmm0
xorpd  0x1c29(%rip),%xmm0
mov    $0x1,%edi
cmp    $0x1,%rcx
je     149c <update_+0x38c>
lea    -0x8(,%rdx,8),%r11
ff
imul   %r12,%r11
lea    (%r14,%r11,1),%rbx
lea    (%r14,%rcx,8),%r10
lea    -0x8(,%r9,8),%rax
ff
imul   %r12,%rax
lea    (%r14,%rax,1),%rbp
add    %r10,%rax
cmp    %rax,%rbx
jae    141e <update_+0x30e>
add    %r11,%r10
cmp    %r10,%rbp
jb     149c <update_+0x38c>
mov    %rcx,%r10
and    $0xfffffffffffffffe,%r10
mov    %rcx,%rdi
or     $0x1,%rdi
movapd %xmm2,%xmm8
unpcklpd %xmm2,%xmm8
movapd %xmm1,%xmm5
unpcklpd %xmm1,%xmm5
movapd %xmm0,%xmm9
unpcklpd %xmm0,%xmm9
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movupd 0x0(%rbp,%rax,8),%xmm7
movupd (%rbx,%rax,8),%xmm4
movapd %xmm8,%xmm6
mulpd  %xmm4,%xmm6
movapd %xmm5,%xmm3
mulpd  %xmm7,%xmm3
addpd  %xmm6,%xmm3
mulpd  %xmm9,%xmm7
mulpd  %xmm5,%xmm4
addpd  %xmm7,%xmm4
movupd %xmm4,(%rbx,%rax,8)
movupd %xmm3,0x0(%rbp,%rax,8)
add    $0x2,%rax
cmp    %rax,%r10
jne    1450 <update_+0x340>
cmp    %r10,%rcx
jne    149c <update_+0x38c>
unpckhpd %xmm3,%xmm3
jmp    14ff <update_+0x3ef>
add    $0xffffffffffffffff,%rdi
lea    -0x8(,%r9,8),%rax
ff
imul   %r12,%rax
add    %r14,%rax
lea    -0x8(,%rdx,8),%rbp
ff
imul   %r12,%rbp
add    %r14,%rbp
xchg   %ax,%ax
movsd  (%rax,%rdi,8),%xmm4
movsd  0x0(%rbp,%rdi,8),%xmm5
movapd %xmm2,%xmm6
mulsd  %xmm5,%xmm6
movapd %xmm1,%xmm3
mulsd  %xmm4,%xmm3
addsd  %xmm6,%xmm3
mulsd  %xmm0,%xmm4
mulsd  %xmm1,%xmm5
addsd  %xmm4,%xmm5
movsd  %xmm5,0x0(%rbp,%rdi,8)
movsd  %xmm3,(%rax,%rdi,8)
add    $0x1,%rdi
cmp    %rdi,%rcx
jne    14c0 <update_+0x3b0>
movsd  %xmm3,0x3b59(%rip)
mov    0xf0(%rsp),%rbp
movq   $0x0,0x0(%r13,%r8,8)
mov    0x10(%rsp),%r8
jmp    130a <update_+0x1fa>
movq   $0x1,0x3b0b(%rip)
movsd  (%rax),%xmm4
mov    $0x1,%ecx
xorpd  %xmm2,%xmm2
ucomisd %xmm2,%xmm4
jb     154a <update_+0x43a>
mov    %r9,0x3af1(%rip)
mov    %r9,%rcx
sub    %rcx,%r9
add    $0x1,%r9
mov    %r9,0x3ae8(%rip)
imul   %r12,%r9
add    %rdx,%r9
movsd  0x0(%r13,%r9,8),%xmm5
divsd  %xmm3,%xmm5
cvttsd2si %xmm4,%eax
mulsd  %xmm5,%xmm4
movsd  %xmm4,0x3b0e(%rip)
mulsd  %xmm5,%xmm0
movsd  %xmm0,0x3b0a(%rip)
imul   %r12,%rcx
add    %rdx,%rcx
movsd  0x0(%r13,%rcx,8),%xmm3
mov    %eax,%ecx
neg    %ecx
cmovs  %eax,%ecx
movsd  %xmm3,0x3abd(%rip)
xorps  %xmm0,%xmm0
cvtsi2sd %ecx,%xmm0
mulsd  %xmm3,%xmm0
mulsd  %xmm3,%xmm0
addsd  %xmm1,%xmm0
mov    %rsi,%rbx
ucomisd %xmm2,%xmm0
jb     1778 <update_+0x668>
sqrtsd %xmm0,%xmm0
jmp    178b <update_+0x67b>
mov    %rsi,%rbx
call   1030 <sqrt@plt>
mov    0x10(%rsp),%r8
mov    %rbx,%rsi
mov    0xf0(%rsp),%rbp
movsd  %xmm0,0x3a74(%rip)
movsd  0x3a94(%rip),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x3a90(%rip)
movsd  0x3a4f(%rip),%xmm8
divsd  %xmm0,%xmm8
movsd  %xmm8,0x3a71(%rip)
mov    (%rsi),%rax
test   %rax,%rax
jle    174a <update_+0x63a>
xorpd  0x19d5(%rip),%xmm1
mov    $0x1,%ecx
cmp    $0x4,%rax
jb     16c1 <update_+0x5b1>
lea    (%r15,%rax,8),%rdx
cmp    %r14,%rdx
jbe    164c <update_+0x53c>
lea    (%r14,%rax,8),%rdx
cmp    %r15,%rdx
ja     16c1 <update_+0x5b1>
mov    %rax,%rdx
and    $0xfffffffffffffffc,%rdx
lea    0x1(%rdx),%rcx
movapd %xmm1,%xmm3
unpcklpd %xmm1,%xmm3
movapd %xmm8,%xmm4
unpcklpd %xmm8,%xmm4
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movupd (%r14,%rdi,8),%xmm5
movupd 0x10(%r14,%rdi,8),%xmm6
movupd (%r15,%rdi,8),%xmm7
movupd 0x10(%r15,%rdi,8),%xmm2
mulpd  %xmm3,%xmm7
mulpd  %xmm3,%xmm2
mulpd  %xmm4,%xmm5
addpd  %xmm7,%xmm5
mulpd  %xmm4,%xmm6
addpd  %xmm2,%xmm6
movupd %xmm5,(%r14,%rdi,8)
movupd %xmm6,0x10(%r14,%rdi,8)
add    $0x4,%rdi
cmp    %rdi,%rdx
jne    1670 <update_+0x560>
cmp    %rdx,%rax
je     174a <update_+0x63a>
mov    %rcx,%rdx
test   $0x1,%al
je     16f2 <update_+0x5e2>
lea    (%rcx,%r12,1),%rdx
movsd  -0x8(%r15,%rcx,8),%xmm2
mulsd  %xmm1,%xmm2
movsd  0x0(%r13,%rdx,8),%xmm3
mulsd  %xmm8,%xmm3
addsd  %xmm2,%xmm3
movsd  %xmm3,0x0(%r13,%rdx,8)
lea    0x1(%rcx),%rdx
cmp    %rcx,%rax
je     174a <update_+0x63a>
add    $0x1,%rax
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%r15,%rdx,8),%xmm2
mulsd  %xmm1,%xmm2
movsd  -0x8(%r14,%rdx,8),%xmm3
mulsd  %xmm8,%xmm3
addsd  %xmm2,%xmm3
movsd  %xmm3,-0x8(%r14,%rdx,8)
movsd  (%r15,%rdx,8),%xmm2
mulsd  %xmm1,%xmm2
movsd  (%r14,%rdx,8),%xmm3
mulsd  %xmm8,%xmm3
addsd  %xmm2,%xmm3
movsd  %xmm3,(%r14,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%rax
jne    1700 <update_+0x5f0>
mov    (%r8),%rax
cmp    $0x1,%rax
jne    1769 <update_+0x659>
xorpd  %xmm1,%xmm1
ucomisd %xmm0,%xmm1
jbe    1769 <update_+0x659>
movq   $0x2,(%r8)
mov    $0x2,%eax
cmp    $0x2,%rax
jge    1aeb <update_+0x9db>
jmp    1afe <update_+0x9ee>
movapd %xmm13,0x30(%rsp)
call   1030 <sqrt@plt>
movapd 0x30(%rsp),%xmm13
divsd  %xmm0,%xmm13
cvttsd2si 0x38e8(%rip),%eax
mov    %eax,%ecx
neg    %ecx
cmovs  %eax,%ecx
xorps  %xmm0,%xmm0
cvtsi2sd %ecx,%xmm0
movsd  %xmm13,0x38c1(%rip)
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     17bf <update_+0x6af>
sqrtsd %xmm0,%xmm0
jmp    17d2 <update_+0x6c2>
movapd %xmm13,0x30(%rsp)
call   1030 <sqrt@plt>
movapd 0x30(%rsp),%xmm13
mov    %rbx,%rsi
mov    0x10(%rsp),%r8
mov    (%rbx),%rax
test   %rax,%rax
jle    1abf <update_+0x9af>
mulsd  %xmm0,%xmm13
movsd  0x387c(%rip),%xmm10
movsd  0x385b(%rip),%xmm12
mov    0x3834(%rip),%r10
movsd  0x3854(%rip),%xmm2
movapd 0x17ec(%rip),%xmm0
xorpd  %xmm0,%xmm2
mov    0x3821(%rip),%r11
movsd  0x3861(%rip),%xmm3
xorpd  %xmm0,%xmm3
movsd  0x385d(%rip),%xmm4
xorpd  %xmm0,%xmm4
mov    $0x1,%r9d
cmp    $0x1,%rax
je     1a21 <update_+0x911>
mov    %rsi,0x30(%rsp)
mov    %r10,0x18(%rsp)
lea    -0x8(,%r10,8),%rdx
ff
imul   %r12,%rdx
lea    (%r14,%rdx,1),%rdi
lea    (%r14,%rax,8),%rcx
add    %rcx,%rdx
mov    %r11,0x20(%rsp)
lea    -0x8(,%r11,8),%rsi
ff
imul   %r12,%rsi
lea    (%r14,%rsi,1),%rbp
add    %rcx,%rsi
lea    (%r15,%rax,8),%rbx
mov    0xf8(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
cmp    %rsi,%rdi
setb   0x50(%rsp)
cmp    %rdx,%rbp
setb   %r11b
cmp    %rbx,%rdi
mov    %r15,%r10
setb   %r15b
cmp    %r10,%rdx
seta   0x68(%rsp)
cmp    %rcx,%rdi
setb   %r8b
cmp    0xf8(%rsp),%rdx
seta   0x48(%rsp)
cmp    %rbx,%rbp
setb   %dl
cmp    %r10,%rsi
seta   %bl
cmp    %rcx,%rbp
setb   %r10b
cmp    0xf8(%rsp),%rsi
seta   %cl
test   %r11b,0x50(%rsp)
jne    19f1 <update_+0x8e1>
and    0x68(%rsp),%r15b
mov    0x30(%rsp),%rsi
mov    0x20(%rsp),%r11
jne    1a0f <update_+0x8ff>
and    0x48(%rsp),%r8b
mov    0xe0(%rsp),%r15
jne    1a17 <update_+0x907>
and    %bl,%dl
mov    0x10(%rsp),%r8
jne    1a1c <update_+0x90c>
and    %cl,%r10b
mov    0x18(%rsp),%r10
jne    1a21 <update_+0x911>
mov    %rax,%rbx
and    $0xfffffffffffffffe,%rbx
mov    %rax,%r9
or     $0x1,%r9
movapd %xmm2,%xmm8
unpcklpd %xmm2,%xmm8
movapd %xmm12,%xmm9
unpcklpd %xmm12,%xmm9
movapd %xmm10,%xmm11
unpcklpd %xmm10,%xmm11
movapd %xmm3,%xmm5
unpcklpd %xmm3,%xmm5
movapd %xmm4,%xmm6
unpcklpd %xmm4,%xmm6
movapd %xmm13,%xmm0
unpcklpd %xmm13,%xmm0
xor    %ecx,%ecx
mov    0xf8(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd (%rdi,%rcx,8),%xmm7
mulpd  %xmm9,%xmm7
movupd (%r15,%rcx,8),%xmm1
mulpd  %xmm8,%xmm1
addpd  %xmm7,%xmm1
mulpd  %xmm11,%xmm1
movupd %xmm1,(%rdi,%rcx,8)
movupd 0x0(%rbp,%rcx,8),%xmm1
movupd (%rdx,%rcx,8),%xmm7
mulpd  %xmm5,%xmm7
addpd  %xmm1,%xmm7
movupd (%r15,%rcx,8),%xmm1
mulpd  %xmm6,%xmm1
addpd  %xmm7,%xmm1
mulpd  %xmm0,%xmm1
movupd %xmm1,0x0(%rbp,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rbx
jne    1990 <update_+0x880>
cmp    %rbx,%rax
jne    1a21 <update_+0x911>
jmp    1abf <update_+0x9af>
mov    0xe0(%rsp),%r15
mov    0x30(%rsp),%rsi
mov    0x10(%rsp),%r8
mov    0x18(%rsp),%r10
mov    0x20(%rsp),%r11
jmp    1a21 <update_+0x911>
mov    0xe0(%rsp),%r15
mov    0x10(%rsp),%r8
mov    0x18(%rsp),%r10
sub    %r9,%rax
add    $0x1,%rax
lea    (%r14,%r9,8),%rbp
add    $0xfffffffffffffff8,%rbp
lea    -0x8(,%r10,8),%rcx
ff
imul   %r12,%rcx
add    %rbp,%rcx
lea    (%r15,%r9,8),%rdi
add    $0xfffffffffffffff8,%rdi
mov    0xf8(%rsp),%rdx
lea    (%rdx,%r9,8),%rbx
add    $0xfffffffffffffff8,%rbx
lea    -0x8(,%r11,8),%rdx
ff
imul   %r12,%rdx
add    %rbp,%rdx
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movsd  (%rdi,%rbp,8),%xmm0
mulsd  %xmm2,%xmm0
movsd  (%rcx,%rbp,8),%xmm1
mulsd  %xmm12,%xmm1
addsd  %xmm0,%xmm1
mulsd  %xmm10,%xmm1
movsd  %xmm1,(%rcx,%rbp,8)
movsd  (%rbx,%rbp,8),%xmm0
mulsd  %xmm3,%xmm0
addsd  (%rdx,%rbp,8),%xmm0
movsd  (%rdi,%rbp,8),%xmm1
mulsd  %xmm4,%xmm1
addsd  %xmm0,%xmm1
mulsd  %xmm13,%xmm1
movsd  %xmm1,(%rdx,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%rax
jne    1a70 <update_+0x960>
xorpd  %xmm1,%xmm1
ucomisd 0x35b5(%rip),%xmm1
mov    0xf0(%rsp),%rbp
jb     1afe <update_+0x9ee>
mov    0xe8(%rsp),%rax
movsd  (%rax),%xmm0
ucomisd %xmm0,%xmm1
jbe    1aeb <update_+0x9db>
addq   $0x1,(%r8)
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1afe <update_+0x9ee>
movb   $0x1,0x356c(%rip)
jmp    1b0b <update_+0x9fb>
cmpb   $0x0,0x3563(%rip)
je     1cee <update_+0xbde>
mov    (%r8),%r9
lea    -0x1(%r9),%rdx
mov    %rdx,(%r8)
mov    (%rsi),%rax
test   %rax,%rax
jle    1cee <update_+0xbde>
imul   %r12,%rdx
mov    $0x1,%ecx
cmp    $0x4,%rax
jb     1c5b <update_+0xb4b>
lea    (%r14,%rax,8),%rdi
lea    -0x10(,%r9,8),%rbx
ff
imul   %r12,%rbx
lea    (%r14,%rbx,1),%rbp
add    %rdi,%rbx
cmp    %r14,%rbx
jbe    1b59 <update_+0xa49>
cmp    %rdi,%rbp
jb     1c5b <update_+0xb4b>
mov    %rax,%rcx
and    $0xfffffffffffffffc,%rcx
lea    -0x4(%rcx),%rdi
mov    %rdi,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rdi,%rdi
je     219d <update_+0x108d>
mov    %r8,%rbx
and    $0xfffffffffffffffe,%rbx
mov    $0x6,%edi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups -0x30(%r14,%rdi,8),%xmm0
movups -0x20(%r14,%rdi,8),%xmm1
movups -0x30(%rbp,%rdi,8),%xmm2
movups -0x20(%rbp,%rdi,8),%xmm3
movups %xmm2,-0x30(%r14,%rdi,8)
movups %xmm3,-0x20(%r14,%rdi,8)
movups %xmm0,-0x30(%rbp,%rdi,8)
movups %xmm1,-0x20(%rbp,%rdi,8)
movupd -0x10(%r14,%rdi,8),%xmm1
movupd (%r14,%rdi,8),%xmm0
movupd -0x10(%rbp,%rdi,8),%xmm2
movupd 0x0(%rbp,%rdi,8),%xmm3
movupd %xmm2,-0x10(%r14,%rdi,8)
movupd %xmm3,(%r14,%rdi,8)
movupd %xmm1,-0x10(%rbp,%rdi,8)
movupd %xmm0,0x0(%rbp,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rbx
jne    1b90 <update_+0xa80>
add    $0xfffffffffffffffb,%rdi
test   $0x1,%r8b
je     1c41 <update_+0xb31>
lea    (%rdi,%r12,1),%rbp
movupd 0x0(%r13,%rbp,8),%xmm1
movupd 0x10(%r13,%rbp,8),%xmm0
add    %rdx,%rdi
movupd 0x0(%r13,%rdi,8),%xmm2
movupd 0x10(%r13,%rdi,8),%xmm3
movupd %xmm2,0x0(%r13,%rbp,8)
movupd %xmm3,0x10(%r13,%rbp,8)
movupd %xmm1,0x0(%r13,%rdi,8)
movupd %xmm0,0x10(%r13,%rdi,8)
cmp    %rcx,%rax
jne    1c57 <update_+0xb47>
unpckhpd %xmm0,%xmm0
mov    0xf0(%rsp),%rbp
jmp    1ce6 <update_+0xbd6>
or     $0x1,%rcx
mov    %rcx,%rdi
test   $0x1,%al
je     1c89 <update_+0xb79>
lea    (%rcx,%r12,1),%rdi
movsd  0x0(%r13,%rdi,8),%xmm0
add    %rcx,%rdx
movsd  0x0(%r13,%rdx,8),%xmm1
movsd  %xmm1,0x0(%r13,%rdi,8)
movsd  %xmm0,0x0(%r13,%rdx,8)
lea    0x1(%rcx),%rdi
cmp    %rcx,%rax
mov    0xf0(%rsp),%rbp
je     1ce6 <update_+0xbd6>
lea    (%r14,%rdi,8),%rdx
lea    -0x10(,%r9,8),%rcx
ff
imul   %rcx,%r12
sub    %rdi,%rax
add    $0x1,%rax
nopl   (%rax)
movsd  -0x8(%rdx),%xmm0
movsd  -0x8(%rdx,%r12,1),%xmm1
movsd  %xmm1,-0x8(%rdx)
movsd  %xmm0,-0x8(%rdx,%r12,1)
movsd  (%rdx),%xmm0
movsd  (%rdx,%r12,1),%xmm1
movsd  %xmm1,(%rdx)
movsd  %xmm0,(%rdx,%r12,1)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rax
jne    1cb0 <update_+0xba0>
movsd  %xmm0,0x3372(%rip)
mov    0x70(%rsp),%rax
mov    (%rax),%r11
test   %r11,%r11
jle    217d <update_+0x106d>
mov    0x28(%rsp),%r13
mov    %r13,%rax
not    %rax
mov    0x78(%rsp),%rdi
lea    (%rdi,%rax,8),%rax
mov    %rax,0x18(%rsp)
mov    (%rsi),%r12
mov    0x0(%rbp),%rax
mov    %rax,0x68(%rsp)
movsd  0x332b(%rip),%xmm11
xorpd  0x12ca(%rip),%xmm11
movsd  0x3339(%rip),%xmm9
movsd  0x3338(%rip),%xmm10
lea    0x2(%r12),%rbx
lea    0x1(%r11),%rax
mov    %rax,0x88(%rsp)
lea    0x1(%r12),%rax
lea    0x8(%rdi,%r12,8),%rcx
mov    %rcx,0x98(%rsp)
lea    0x0(,%r13,8),%r10
lea    0x8(,%r13,8),%rcx
mov    %rcx,0x90(%rsp)
movq   %r12,%xmm0
pshufd $0x44,%xmm0,%xmm14
lea    (%rdi,%r12,8),%rcx
lea    0x0(,%r12,8),%rdx
mov    $0x8,%r8d
mov    $0x8,%r9d
sub    %rdx,%r9
imul   %r13,%r9
mov    %rcx,0x30(%rsp)
add    %rcx,%r9
mov    %r13,%rcx
shl    $0x4,%rcx
mov    %rcx,0x10(%rsp)
sub    %r10,%r8
imul   %r12,%r8
add    %rdi,%r8
xor    $0xfffffffffffffff8,%rdx
mov    %rdx,0xa0(%rsp)
mov    $0x1,%ecx
movdqa 0x122b(%rip),%xmm8
movdqa 0x1232(%rip),%xmm12
pxor   %xmm12,%xmm14
movdqa 0x1234(%rip),%xmm13
xor    %ebp,%ebp
mov    %rax,0x48(%rsp)
mov    %rax,0x50(%rsp)
mov    0xf8(%rsp),%rdx
mov    0xe8(%rsp),%r14
mov    %r11,%rsi
mov    %r11,0x58(%rsp)
jmp    1e64 <update_+0xd54>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x70(%rsp),%rcx
lea    0x1(%rcx),%rax
add    $0x1,%rbx
add    $0x1,%rbp
add    $0x8,%r9
add    %r10,%rdi
add    $0x8,%r8
addq   $0x1,0x50(%rsp)
addq   $0x8,0x30(%rsp)
cmp    %rsi,%rcx
mov    %rax,%rcx
je     2163 <update_+0x1053>
lea    (%r12,%rcx,1),%rax
mov    %rcx,0x70(%rsp)
mov    %rbp,%r11
mov    %rsi,%rbp
mov    %rcx,%rsi
imul   %r13,%rsi
add    0x68(%rsp),%rsi
mov    0x18(%rsp),%rcx
movsd  (%rcx,%rsi,8),%xmm0
mov    %rbp,%rsi
mov    %r11,%rbp
movsd  %xmm0,-0x8(%rdx,%rax,8)
movsd  -0x8(%r15,%rax,8),%xmm7
movapd %xmm0,%xmm2
mulsd  %xmm11,%xmm2
movapd %xmm9,%xmm1
mulsd  %xmm7,%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm10,%xmm1
mulsd  (%r14),%xmm0
mulsd  %xmm11,%xmm7
subsd  %xmm0,%xmm7
divsd  %xmm10,%xmm7
test   %rax,%rax
jle    1e30 <update_+0xd20>
mov    0x48(%rsp),%rax
add    %rbp,%rax
mov    $0x1,%r11d
mov    %rax,0x20(%rsp)
cmp    $0x2,%rax
jb     2100 <update_+0xff0>
cmp    $0x1,%r13
jne    2100 <update_+0xff0>
mov    %r8,0x80(%rsp)
mov    0x78(%rsp),%rcx
lea    (%rcx,%rbp,8),%r8
mov    0x48(%rsp),%rsi
lea    (%rsi,%rbp,2),%rsi
lea    (%rcx,%rsi,8),%rsi
mov    0x20(%rsp),%r14
lea    (%r15,%r14,8),%rax
lea    (%rdx,%r14,8),%rdx
imul   %rbp,%r13
mov    0x90(%rsp),%r14
imul   %rbp,%r14
add    0x98(%rsp),%r14
cmp    %rax,%r8
setb   0x60(%rsp)
cmp    %r15,%rsi
seta   0xf(%rsp)
cmp    %rdx,%r8
setb   %r8b
cmp    0xf8(%rsp),%rsi
seta   0xe(%rsp)
lea    (%rcx,%r13,8),%rsi
cmp    %rax,%rsi
setb   %r13b
cmp    %r15,%r14
seta   0xd(%rsp)
cmp    %rdx,%rsi
setb   %r15b
cmp    0xf8(%rsp),%r14
mov    0xf8(%rsp),%rdx
seta   %cl
mov    0xf(%rsp),%al
test   %al,0x60(%rsp)
jne    20de <update_+0xfce>
and    0xe(%rsp),%r8b
mov    0xe8(%rsp),%r14
mov    0x58(%rsp),%rsi
mov    0x80(%rsp),%r8
jne    20cf <update_+0xfbf>
and    0xd(%rsp),%r13b
jne    20cf <update_+0xfbf>
mov    %ecx,%eax
and    %cl,%r15b
mov    0x28(%rsp),%r13
mov    0xe0(%rsp),%r15
jne    2100 <update_+0xff0>
mov    0x50(%rsp),%rsi
and    $0xfffffffffffffffe,%rsi
mov    0x20(%rsp),%r11
mov    %r11,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,0x60(%rsp)
or     $0x1,%r11
movapd %xmm1,%xmm15
unpcklpd %xmm1,%xmm15
movapd %xmm7,%xmm2
unpcklpd %xmm7,%xmm2
xor    %r15d,%r15d
xor    %eax,%eax
movdqa %xmm8,%xmm0
jmp    2033 <update_+0xf23>
nopl   0x0(%rax,%rax,1)
add    $0x2,%rax
paddq  %xmm13,%xmm0
add    0x10(%rsp),%r15
cmp    %rax,%rsi
je     20b1 <update_+0xfa1>
movupd (%rdi,%rax,8),%xmm5
mov    0xe0(%rsp),%rcx
movupd (%rcx,%rax,8),%xmm6
mulpd  %xmm15,%xmm6
addpd  %xmm5,%xmm6
movupd (%rdx,%rax,8),%xmm5
mulpd  %xmm2,%xmm5
addpd  %xmm6,%xmm5
movupd %xmm5,(%rdi,%rax,8)
movdqa %xmm0,%xmm6
pxor   %xmm12,%xmm6
movdqa %xmm6,%xmm3
pcmpgtd %xmm14,%xmm3
pcmpeqd %xmm14,%xmm6
pshufd $0xf5,%xmm6,%xmm4
pand   %xmm3,%xmm4
pshufd $0xf5,%xmm3,%xmm6
por    %xmm4,%xmm6
movd   %xmm6,%ecx
test   $0x1,%cl
je     2098 <update_+0xf88>
movlpd %xmm5,(%r8,%r15,1)
pextrw $0x4,%xmm6,%ecx
test   $0x1,%cl
je     2020 <update_+0xf10>
movhpd %xmm5,(%r9,%r15,1)
jmp    2020 <update_+0xf10>
mov    0x60(%rsp),%rax
cmp    %rax,0x20(%rsp)
mov    0xe0(%rsp),%r15
mov    0x58(%rsp),%rsi
jne    2100 <update_+0xff0>
jmp    1e30 <update_+0xd20>
mov    0x28(%rsp),%r13
mov    0xe0(%rsp),%r15
jmp    2100 <update_+0xff0>
mov    0x28(%rsp),%r13
mov    0xe8(%rsp),%r14
mov    0xe0(%rsp),%r15
mov    0x58(%rsp),%rsi
mov    0x80(%rsp),%r8
mov    0xa0(%rsp),%rax
lea    (%rax,%r11,8),%rax
imul   %r13,%rax
add    0x30(%rsp),%rax
jmp    2130 <update_+0x1020>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r11
add    %r10,%rax
cmp    %r11,%rbx
je     1e30 <update_+0xd20>
movsd  -0x8(%r15,%r11,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  -0x8(%rdi,%r11,8),%xmm2
movsd  -0x8(%rdx,%r11,8),%xmm0
mulsd  %xmm7,%xmm0
addsd  %xmm2,%xmm0
movsd  %xmm0,-0x8(%rdi,%r11,8)
cmp    %r12,%r11
jle    2120 <update_+0x1010>
movsd  %xmm0,(%rax)
jmp    2120 <update_+0x1010>
movsd  %xmm1,0x2f1d(%rip)
movsd  %xmm7,0x2f1d(%rip)
mov    0x88(%rsp),%rax
jmp    2182 <update_+0x1072>
mov    $0x1,%eax
mov    %rax,0x2ea7(%rip)
xor    %eax,%eax
add    $0xa8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    $0x1,%edi
test   $0x1,%r8b
jne    1c02 <update_+0xaf2>
jmp    1c41 <update_+0xb31>

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

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