void dpotrf_diag_lib(int m, int n, double *C, int sdc, double *D, int sdd) {
  const int bs = 4;
  int ii, jj, ll, ll_max;
  double alpha0, alpha1, alpha2, alpha3;
  for (jj = 0; jj < n - 3; jj += 4) {
    alpha0 = 1.0 / sqrt(C[(jj)*sdc + 0 + (jj + 0) * bs]);
    alpha1 = 1.0 / sqrt(C[(jj)*sdc + 1 + (jj + 1) * bs]);
    alpha2 = 1.0 / sqrt(C[(jj)*sdc + 2 + (jj + 2) * bs]);
    alpha3 = 1.0 / sqrt(C[(jj)*sdc + 3 + (jj + 3) * bs]);
    D[(jj)*sdc + 0 + (jj + 0) * bs] = alpha0;
    D[(jj)*sdc + 1 + (jj + 0) * bs] = 0.0;
    D[(jj)*sdc + 2 + (jj + 0) * bs] = 0.0;
    D[(jj)*sdc + 3 + (jj + 0) * bs] = 0.0;
    D[(jj)*sdc + 1 + (jj + 1) * bs] = alpha1;
    D[(jj)*sdc + 2 + (jj + 1) * bs] = 0.0;
    D[(jj)*sdc + 3 + (jj + 1) * bs] = 0.0;
    D[(jj)*sdc + 2 + (jj + 2) * bs] = alpha2;
    D[(jj)*sdc + 3 + (jj + 2) * bs] = 0.0;
    D[(jj)*sdc + 3 + (jj + 3) * bs] = alpha3;
    for (ll = jj + 4; ll < n / bs * bs; ll += 4) {
      D[(ll)*sdd + 0 + (jj + 0) * bs] = 0.0;
      D[(ll)*sdd + 1 + (jj + 0) * bs] = 0.0;
      D[(ll)*sdd + 2 + (jj + 0) * bs] = 0.0;
      D[(ll)*sdd + 3 + (jj + 0) * bs] = 0.0;
      D[(ll)*sdd + 0 + (jj + 1) * bs] = 0.0;
      D[(ll)*sdd + 1 + (jj + 1) * bs] = 0.0;
      D[(ll)*sdd + 2 + (jj + 1) * bs] = 0.0;
      D[(ll)*sdd + 3 + (jj + 1) * bs] = 0.0;
      D[(ll)*sdd + 0 + (jj + 2) * bs] = 0.0;
      D[(ll)*sdd + 1 + (jj + 2) * bs] = 0.0;
      D[(ll)*sdd + 2 + (jj + 2) * bs] = 0.0;
      D[(ll)*sdd + 3 + (jj + 2) * bs] = 0.0;
      D[(ll)*sdd + 0 + (jj + 3) * bs] = 0.0;
      D[(ll)*sdd + 1 + (jj + 3) * bs] = 0.0;
      D[(ll)*sdd + 2 + (jj + 3) * bs] = 0.0;
      D[(ll)*sdd + 3 + (jj + 3) * bs] = 0.0;
    }
    for (; ll < m; ll += 4) {
      D[(ll)*sdd + 0 + (jj + 0) * bs] =
          alpha0 * C[(ll)*sdc + 0 + (jj + 0) * bs];
      D[(ll)*sdd + 1 + (jj + 0) * bs] =
          alpha0 * C[(ll)*sdc + 1 + (jj + 0) * bs];
      D[(ll)*sdd + 2 + (jj + 0) * bs] =
          alpha0 * C[(ll)*sdc + 2 + (jj + 0) * bs];
      D[(ll)*sdd + 3 + (jj + 0) * bs] =
          alpha0 * C[(ll)*sdc + 3 + (jj + 0) * bs];
      D[(ll)*sdd + 0 + (jj + 1) * bs] =
          alpha1 * C[(ll)*sdc + 0 + (jj + 1) * bs];
      D[(ll)*sdd + 1 + (jj + 1) * bs] =
          alpha1 * C[(ll)*sdc + 1 + (jj + 1) * bs];
      D[(ll)*sdd + 2 + (jj + 1) * bs] =
          alpha1 * C[(ll)*sdc + 2 + (jj + 1) * bs];
      D[(ll)*sdd + 3 + (jj + 1) * bs] =
          alpha1 * C[(ll)*sdc + 3 + (jj + 1) * bs];
      D[(ll)*sdd + 0 + (jj + 2) * bs] =
          alpha2 * C[(ll)*sdc + 0 + (jj + 2) * bs];
      D[(ll)*sdd + 1 + (jj + 2) * bs] =
          alpha2 * C[(ll)*sdc + 1 + (jj + 2) * bs];
      D[(ll)*sdd + 2 + (jj + 2) * bs] =
          alpha2 * C[(ll)*sdc + 2 + (jj + 2) * bs];
      D[(ll)*sdd + 3 + (jj + 2) * bs] =
          alpha2 * C[(ll)*sdc + 3 + (jj + 2) * bs];
      D[(ll)*sdd + 0 + (jj + 3) * bs] =
          alpha3 * C[(ll)*sdc + 0 + (jj + 3) * bs];
      D[(ll)*sdd + 1 + (jj + 3) * bs] =
          alpha3 * C[(ll)*sdc + 1 + (jj + 3) * bs];
      D[(ll)*sdd + 2 + (jj + 3) * bs] =
          alpha3 * C[(ll)*sdc + 2 + (jj + 3) * bs];
      D[(ll)*sdd + 3 + (jj + 3) * bs] =
          alpha3 * C[(ll)*sdc + 3 + (jj + 3) * bs];
    }
  }
  for (ii = 0; ii < n - jj; ii++) {
    alpha0 = 1.0 / sqrt(C[(jj)*sdc + ii + (jj + ii) * bs]);
    D[(jj)*sdc + ii + (jj + ii) * bs] = alpha0;
    ll_max = n - jj < 4 ? n - jj : 4;
    for (ll = ii + 1; ll < ll_max; ll++)
      D[(jj)*sdc + ll + (jj + ii) * bs] = 0.0;
    for (; ll < 4; ll++)
      D[(jj)*sdc + ll + (jj + ii) * bs] =
          alpha0 * C[(jj)*sdc + ll + (jj + ii) * bs];
    for (ll = jj + 4; ll < n / bs * bs + 8; ll += 4) {
      D[(ll)*sdd + 0 + (jj + ii) * bs] = 0.0;
      D[(ll)*sdd + 1 + (jj + ii) * bs] = 0.0;
      D[(ll)*sdd + 2 + (jj + ii) * bs] = 0.0;
      D[(ll)*sdd + 3 + (jj + ii) * bs] = 0.0;
    }
    for (; ll < m; ll += 4) {
      D[(ll)*sdd + 0 + (jj + ii) * bs] =
          alpha0 * C[(ll)*sdc + 0 + (jj + ii) * bs];
      D[(ll)*sdd + 1 + (jj + ii) * bs] =
          alpha0 * C[(ll)*sdc + 1 + (jj + ii) * bs];
      D[(ll)*sdd + 2 + (jj + ii) * bs] =
          alpha0 * C[(ll)*sdc + 2 + (jj + ii) * bs];
      D[(ll)*sdd + 3 + (jj + ii) * bs] =
          alpha0 * C[(ll)*sdc + 3 + (jj + ii) * bs];
    }
  }
}


x86 assembly (clang, -O0):
<dpotrf_diag_lib>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9d,-0x24(%rbp)
movl   $0x4,-0x28(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    $0x3,%ecx
cmp    %ecx,%eax
jge    1abe <dpotrf_diag_lib+0x9ae>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    $0x0,%ecx
mov    -0x30(%rbp),%edx
add    $0x0,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1030 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0xe83(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    $0x1,%ecx
mov    -0x30(%rbp),%edx
add    $0x1,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1030 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0xe49(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    $0x2,%ecx
mov    -0x30(%rbp),%edx
add    $0x2,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1030 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0xe0f(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    $0x3,%ecx
mov    -0x30(%rbp),%edx
add    $0x3,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1030 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0xdd5(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x40(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    $0x0,%ecx
mov    -0x30(%rbp),%edx
add    $0x0,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    $0x1,%ecx
mov    -0x30(%rbp),%edx
add    $0x0,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    $0x2,%ecx
mov    -0x30(%rbp),%edx
add    $0x0,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    $0x3,%ecx
mov    -0x30(%rbp),%edx
add    $0x0,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x48(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    $0x1,%ecx
mov    -0x30(%rbp),%edx
add    $0x1,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    $0x2,%ecx
mov    -0x30(%rbp),%edx
add    $0x1,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    $0x3,%ecx
mov    -0x30(%rbp),%edx
add    $0x1,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x50(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    $0x2,%ecx
mov    -0x30(%rbp),%edx
add    $0x2,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    $0x3,%ecx
mov    -0x30(%rbp),%edx
add    $0x2,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    $0x3,%ecx
mov    -0x30(%rbp),%edx
add    $0x3,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x8(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x5c(%rbp),%eax
shl    $0x2,%ecx
cmp    %ecx,%eax
jge    161c <dpotrf_diag_lib+0x50c>
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    $0x0,%ecx
mov    -0x30(%rbp),%edx
add    $0x0,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    $0x1,%ecx
mov    -0x30(%rbp),%edx
add    $0x0,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    $0x2,%ecx
mov    -0x30(%rbp),%edx
add    $0x0,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    $0x3,%ecx
mov    -0x30(%rbp),%edx
add    $0x0,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    $0x0,%ecx
mov    -0x30(%rbp),%edx
add    $0x1,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    $0x1,%ecx
mov    -0x30(%rbp),%edx
add    $0x1,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    $0x2,%ecx
mov    -0x30(%rbp),%edx
add    $0x1,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    $0x3,%ecx
mov    -0x30(%rbp),%edx
add    $0x1,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    $0x0,%ecx
mov    -0x30(%rbp),%edx
add    $0x2,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    $0x1,%ecx
mov    -0x30(%rbp),%edx
add    $0x2,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    $0x2,%ecx
mov    -0x30(%rbp),%edx
add    $0x2,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    $0x3,%ecx
mov    -0x30(%rbp),%edx
add    $0x2,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    $0x0,%ecx
mov    -0x30(%rbp),%edx
add    $0x3,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    $0x1,%ecx
mov    -0x30(%rbp),%edx
add    $0x3,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    $0x2,%ecx
mov    -0x30(%rbp),%edx
add    $0x3,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    $0x3,%ecx
mov    -0x30(%rbp),%edx
add    $0x3,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x34(%rbp)
jmp    13ad <dpotrf_diag_lib+0x29d>
jmp    1621 <dpotrf_diag_lib+0x511>
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1aab <dpotrf_diag_lib+0x99b>
movsd  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    $0x0,%ecx
mov    -0x30(%rbp),%edx
add    $0x0,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    $0x0,%ecx
mov    -0x30(%rbp),%edx
add    $0x0,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    $0x1,%ecx
mov    -0x30(%rbp),%edx
add    $0x0,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    $0x1,%ecx
mov    -0x30(%rbp),%edx
add    $0x0,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    $0x2,%ecx
mov    -0x30(%rbp),%edx
add    $0x0,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    $0x2,%ecx
mov    -0x30(%rbp),%edx
add    $0x0,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    $0x3,%ecx
mov    -0x30(%rbp),%edx
add    $0x0,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    $0x3,%ecx
mov    -0x30(%rbp),%edx
add    $0x0,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    $0x0,%ecx
mov    -0x30(%rbp),%edx
add    $0x1,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    $0x0,%ecx
mov    -0x30(%rbp),%edx
add    $0x1,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    $0x1,%ecx
mov    -0x30(%rbp),%edx
add    $0x1,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    $0x1,%ecx
mov    -0x30(%rbp),%edx
add    $0x1,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    $0x2,%ecx
mov    -0x30(%rbp),%edx
add    $0x1,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    $0x2,%ecx
mov    -0x30(%rbp),%edx
add    $0x1,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    $0x3,%ecx
mov    -0x30(%rbp),%edx
add    $0x1,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    $0x3,%ecx
mov    -0x30(%rbp),%edx
add    $0x1,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x50(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    $0x0,%ecx
mov    -0x30(%rbp),%edx
add    $0x2,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    $0x0,%ecx
mov    -0x30(%rbp),%edx
add    $0x2,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x50(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    $0x1,%ecx
mov    -0x30(%rbp),%edx
add    $0x2,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    $0x1,%ecx
mov    -0x30(%rbp),%edx
add    $0x2,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x50(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    $0x2,%ecx
mov    -0x30(%rbp),%edx
add    $0x2,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    $0x2,%ecx
mov    -0x30(%rbp),%edx
add    $0x2,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x50(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    $0x3,%ecx
mov    -0x30(%rbp),%edx
add    $0x2,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    $0x3,%ecx
mov    -0x30(%rbp),%edx
add    $0x2,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    $0x0,%ecx
mov    -0x30(%rbp),%edx
add    $0x3,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    $0x0,%ecx
mov    -0x30(%rbp),%edx
add    $0x3,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    $0x1,%ecx
mov    -0x30(%rbp),%edx
add    $0x3,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    $0x1,%ecx
mov    -0x30(%rbp),%edx
add    $0x3,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    $0x2,%ecx
mov    -0x30(%rbp),%edx
add    $0x3,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    $0x2,%ecx
mov    -0x30(%rbp),%edx
add    $0x3,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    $0x3,%ecx
mov    -0x30(%rbp),%edx
add    $0x3,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    $0x3,%ecx
mov    -0x30(%rbp),%edx
add    $0x3,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x34(%rbp)
jmp    1621 <dpotrf_diag_lib+0x511>
jmp    1ab0 <dpotrf_diag_lib+0x9a0>
mov    -0x30(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x30(%rbp)
jmp    113b <dpotrf_diag_lib+0x2b>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    -0x30(%rbp),%ecx
cmp    %ecx,%eax
jge    1e2a <dpotrf_diag_lib+0xd1a>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x2c(%rbp),%ecx
mov    -0x30(%rbp),%edx
add    -0x2c(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1030 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0x4f9(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x40(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x2c(%rbp),%ecx
mov    -0x30(%rbp),%edx
add    -0x2c(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%eax
sub    -0x30(%rbp),%eax
cmp    $0x4,%eax
jge    1b53 <dpotrf_diag_lib+0xa43>
mov    -0x8(%rbp),%eax
sub    -0x30(%rbp),%eax
mov    %eax,-0x60(%rbp)
jmp    1b60 <dpotrf_diag_lib+0xa50>
mov    $0x4,%eax
mov    %eax,-0x60(%rbp)
jmp    1b60 <dpotrf_diag_lib+0xa50>
mov    -0x60(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1bad <dpotrf_diag_lib+0xa9d>
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x34(%rbp),%ecx
mov    -0x30(%rbp),%edx
add    -0x2c(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1b6f <dpotrf_diag_lib+0xa5f>
jmp    1bb2 <dpotrf_diag_lib+0xaa2>
cmpl   $0x4,-0x34(%rbp)
jge    1c11 <dpotrf_diag_lib+0xb01>
movsd  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x34(%rbp),%ecx
mov    -0x30(%rbp),%edx
add    -0x2c(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x34(%rbp),%ecx
mov    -0x30(%rbp),%edx
add    -0x2c(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1bb2 <dpotrf_diag_lib+0xaa2>
mov    -0x30(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x8(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x64(%rbp),%eax
shl    $0x2,%ecx
add    $0x8,%ecx
cmp    %ecx,%eax
jge    1cdc <dpotrf_diag_lib+0xbcc>
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    $0x0,%ecx
mov    -0x30(%rbp),%edx
add    -0x2c(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    $0x1,%ecx
mov    -0x30(%rbp),%edx
add    -0x2c(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    $0x2,%ecx
mov    -0x30(%rbp),%edx
add    -0x2c(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    $0x3,%ecx
mov    -0x30(%rbp),%edx
add    -0x2c(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x34(%rbp)
jmp    1c1a <dpotrf_diag_lib+0xb0a>
jmp    1ce1 <dpotrf_diag_lib+0xbd1>
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1e17 <dpotrf_diag_lib+0xd07>
movsd  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    $0x0,%ecx
mov    -0x30(%rbp),%edx
add    -0x2c(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    $0x0,%ecx
mov    -0x30(%rbp),%edx
add    -0x2c(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    $0x1,%ecx
mov    -0x30(%rbp),%edx
add    -0x2c(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    $0x1,%ecx
mov    -0x30(%rbp),%edx
add    -0x2c(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    $0x2,%ecx
mov    -0x30(%rbp),%edx
add    -0x2c(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    $0x2,%ecx
mov    -0x30(%rbp),%edx
add    -0x2c(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    $0x3,%ecx
mov    -0x30(%rbp),%edx
add    -0x2c(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    $0x3,%ecx
mov    -0x30(%rbp),%edx
add    -0x2c(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x34(%rbp)
jmp    1ce1 <dpotrf_diag_lib+0xbd1>
jmp    1e1c <dpotrf_diag_lib+0xd0c>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1ac5 <dpotrf_diag_lib+0x9b5>
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<dpotrf_diag_lib>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x108,%rsp
mov    %r8,(%rsp)
mov    %rdx,%r10
xor    %edx,%edx
movslq %r9d,%rax
mov    %rax,0x70(%rsp)
movslq %ecx,%rax
mov    %rax,0x58(%rsp)
mov    %edi,0x6c(%rsp)
movslq %edi,%rax
cmp    $0x4,%esi
mov    %r10,0x60(%rsp)
mov    %rax,0xe8(%rsp)
jl     1818 <dpotrf_diag_lib+0x708>
lea    -0x3(%rsi),%eax
mov    %rax,0x78(%rsp)
mov    %rsi,0xf0(%rsp)
mov    %esi,%r15d
and    $0xfffffffc,%r15d
mov    0x70(%rsp),%rax
lea    0x0(,%rax,4),%r13d
lea    0x3(,%rax,4),%ecx
mov    %ecx,0x50(%rsp)
mov    %rax,%rcx
shl    $0x5,%rcx
mov    (%rsp),%rdx
add    %rcx,%rdx
add    $0x60,%rdx
mov    %rdx,0x48(%rsp)
mov    %rcx,0x38(%rsp)
add    $0x80,%rcx
mov    %rcx,0xd0(%rsp)
mov    %rax,%rcx
shl    $0x20,%rcx
mov    %rcx,0x100(%rsp)
shl    $0x22,%rax
mov    %rax,0x28(%rsp)
mov    0x58(%rsp),%rax
mov    %rax,%rcx
shl    $0x5,%rcx
mov    %rcx,0xc0(%rsp)
mov    %rax,%rcx
shl    $0x20,%rcx
mov    %rcx,0xf8(%rsp)
shl    $0x22,%rax
mov    %rax,0xb8(%rsp)
mov    $0x4,%eax
mov    %rax,0xb0(%rsp)
mov    $0xc,%eax
mov    %rax,0x88(%rsp)
xor    %eax,%eax
mov    %rax,0x80(%rsp)
xorpd  %xmm5,%xmm5
xor    %edx,%edx
mov    %r15,0xe0(%rsp)
mov    %r13d,0xd8(%rsp)
jmp    128d <dpotrf_diag_lib+0x17d>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
addq   $0x4,0xb0(%rsp)
mov    0xd8(%rsp),%r13d
add    %r13d,0x50(%rsp)
mov    0xd0(%rsp),%rax
add    %rax,0x48(%rsp)
addq   $0x10,0x88(%rsp)
addq   $0x10,0x80(%rsp)
mov    0x20(%rsp),%rdx
cmp    0x78(%rsp),%rdx
mov    0xe0(%rsp),%r15
jae    1810 <dpotrf_diag_lib+0x700>
mov    %rdx,%rax
mov    0x58(%rsp),%rcx
imul   %rcx,%rax
mov    %ecx,%ebp
imul   %edx,%ebp
lea    0x0(,%rdx,4),%r9
lea    (%rax,%rdx,4),%rax
movsd  (%r10,%rax,8),%xmm0
ucomisd %xmm5,%xmm0
mov    %r9,0x8(%rsp)
mov    %rdx,0x20(%rsp)
mov    %rax,0x98(%rsp)
jb     12e0 <dpotrf_diag_lib+0x1d0>
xorps  %xmm1,%xmm1
sqrtsd %xmm0,%xmm1
jmp    12f7 <dpotrf_diag_lib+0x1e7>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
call   1030 <sqrt@plt>
mov    0x8(%rsp),%r9
xorpd  %xmm5,%xmm5
mov    0x60(%rsp),%r10
movapd %xmm0,%xmm1
mov    %ebp,%eax
or     $0x1,%eax
mov    %r9,%rcx
or     $0x4,%rcx
movslq %eax,%rdx
lea    (%rcx,%rdx,1),%rax
movsd  (%r10,%rax,8),%xmm0
ucomisd %xmm5,%xmm0
mov    %rcx,0x40(%rsp)
mov    %rax,0x10(%rsp)
movsd  %xmm1,0x30(%rsp)
mov    %rdx,0xa8(%rsp)
jb     1340 <dpotrf_diag_lib+0x230>
xorps  %xmm1,%xmm1
sqrtsd %xmm0,%xmm1
jmp    1357 <dpotrf_diag_lib+0x247>
nopw   0x0(%rax,%rax,1)
call   1030 <sqrt@plt>
mov    0x8(%rsp),%r9
xorpd  %xmm5,%xmm5
mov    0x60(%rsp),%r10
movapd %xmm0,%xmm1
mov    %ebp,%eax
or     $0x2,%eax
mov    %r9,%r12
or     $0x8,%r12
cltq
lea    (%r12,%rax,1),%r14
movsd  (%r10,%r14,8),%xmm0
ucomisd %xmm5,%xmm0
movsd  %xmm1,0xa0(%rsp)
mov    %rax,0x90(%rsp)
jb     1390 <dpotrf_diag_lib+0x280>
sqrtsd %xmm0,%xmm7
jmp    13a7 <dpotrf_diag_lib+0x297>
nopl   0x0(%rax)
call   1030 <sqrt@plt>
mov    0x8(%rsp),%r9
xorpd  %xmm5,%xmm5
mov    0x60(%rsp),%r10
movapd %xmm0,%xmm7
or     $0x3,%ebp
mov    %r9,%rax
or     $0xc,%rax
movslq %ebp,%rbp
mov    %rax,%rbx
add    %rbp,%rax
movsd  (%r10,%rax,8),%xmm0
ucomisd %xmm5,%xmm0
mov    %rax,0x18(%rsp)
jb     13e0 <dpotrf_diag_lib+0x2d0>
sqrtsd %xmm0,%xmm0
jmp    1400 <dpotrf_diag_lib+0x2f0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  %xmm7,0xc8(%rsp)
call   1030 <sqrt@plt>
movsd  0xc8(%rsp),%xmm7
mov    0x8(%rsp),%r9
xorpd  %xmm5,%xmm5
mov    0x38(%rsp),%r8
mov    0x40(%rsp),%r11
mov    %rbx,%r10
mov    0x10(%rsp),%rdx
movsd  0x30(%rsp),%xmm2
mov    0xa8(%rsp),%rax
movsd  0xa0(%rsp),%xmm3
mov    0x98(%rsp),%rsi
mov    0x90(%rsp),%rdi
movsd  0xbbf(%rip),%xmm4
movapd %xmm4,%xmm1
divsd  %xmm2,%xmm1
mov    (%rsp),%rcx
movsd  %xmm1,(%rcx,%rsi,8)
add    %r9,%rax
xorps  %xmm6,%xmm6
movups %xmm6,(%rcx,%rax,8)
lea    (%r9,%rbp,1),%rax
movq   $0x0,(%rcx,%rax,8)
movapd %xmm4,%xmm2
divsd  %xmm3,%xmm2
movsd  %xmm2,(%rcx,%rdx,8)
movapd %xmm4,%xmm3
divsd  %xmm7,%xmm3
divsd  %xmm0,%xmm4
add    %r11,%rdi
movups %xmm6,(%rcx,%rdi,8)
movsd  %xmm3,(%rcx,%r14,8)
add    %r12,%rbp
movq   $0x0,(%rcx,%rbp,8)
mov    0x18(%rsp),%rax
movsd  %xmm4,(%rcx,%rax,8)
mov    0x20(%rsp),%rdi
add    $0x4,%rdi
mov    %rdi,%rsi
mov    0x48(%rsp),%rax
mov    0x50(%rsp),%ecx
mov    0xb0(%rsp),%rdx
mov    %rdi,0x20(%rsp)
cmp    %r15,%rdi
jae    15a6 <dpotrf_diag_lib+0x496>
xchg   %ax,%ax
movq   $0x0,-0x60(%rax)
lea    -0x2(%rcx),%esi
movslq %esi,%rsi
lea    (%r9,%rsi,1),%rdi
mov    (%rsp),%rbx
movq   $0x0,(%rbx,%rdi,8)
lea    -0x1(%rcx),%edi
movslq %edi,%rdi
lea    (%r9,%rdi,1),%rbp
movq   $0x0,(%rbx,%rbp,8)
movslq %ecx,%rcx
lea    (%r9,%rcx,1),%rbp
movq   $0x0,(%rbx,%rbp,8)
movq   $0x0,-0x40(%rax)
lea    (%r11,%rsi,1),%rbp
movq   $0x0,(%rbx,%rbp,8)
lea    (%r11,%rdi,1),%rbp
movq   $0x0,(%rbx,%rbp,8)
lea    (%r11,%rcx,1),%rbp
movq   $0x0,(%rbx,%rbp,8)
movq   $0x0,-0x20(%rax)
lea    (%r12,%rsi,1),%rbp
movq   $0x0,(%rbx,%rbp,8)
lea    (%r12,%rdi,1),%rbp
movq   $0x0,(%rbx,%rbp,8)
lea    (%r12,%rcx,1),%rbp
movq   $0x0,(%rbx,%rbp,8)
movq   $0x0,(%rax)
add    %r10,%rsi
movq   $0x0,(%rbx,%rsi,8)
add    %r10,%rdi
movq   $0x0,(%rbx,%rdi,8)
lea    (%r10,%rcx,1),%rsi
movq   $0x0,(%rbx,%rsi,8)
add    $0x4,%rdx
add    %r13d,%ecx
add    %r8,%rax
mov    %rdx,%rsi
cmp    %r15,%rdx
jb     14d0 <dpotrf_diag_lib+0x3c0>
cmp    0x6c(%rsp),%esi
mov    %r10,%rdi
mov    0x60(%rsp),%r10
mov    %r12,0x30(%rsp)
jge    1240 <dpotrf_diag_lib+0x130>
movslq %esi,%r13
mov    0x100(%rsp),%r9
imul   %r13,%r9
mov    0x58(%rsp),%rax
imul   %r13,%rax
add    0x88(%rsp),%rax
lea    (%r10,%rax,8),%r15
mov    0xf8(%rsp),%rsi
imul   %r13,%rsi
mov    0x70(%rsp),%rax
imul   %r13,%rax
add    0x80(%rsp),%rax
mov    (%rsp),%rbx
lea    (%rbx,%rax,8),%r12
cs nopw 0x0(%rax,%rax,1)
mov    %rsi,0x10(%rsp)
mov    %r13,0x18(%rsp)
movsd  -0x60(%r15),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,(%r12)
sar    $0x20,%rsi
mov    %rsi,%rax
or     $0x1,%rax
mov    (%rsp),%r8
mov    0x8(%rsp),%r14
lea    (%rax,%r14,1),%rcx
movsd  (%r10,%rcx,8),%xmm0
mulsd  %xmm1,%xmm0
mov    %r9,%rcx
sar    $0x20,%rcx
mov    %rcx,%rbx
or     $0x1,%rbx
lea    (%rbx,%r14,1),%rdx
movsd  %xmm0,(%r8,%rdx,8)
mov    %rsi,%rbp
or     $0x2,%rbp
lea    (%r14,%rbp,1),%rdx
movsd  (%r10,%rdx,8),%xmm0
mulsd  %xmm1,%xmm0
mov    %rcx,%rdx
or     $0x2,%rdx
lea    (%rdx,%r14,1),%r13
movsd  %xmm0,(%r8,%r13,8)
or     $0x3,%rsi
mov    %rdi,%r13
lea    (%rsi,%r14,1),%rdi
movsd  (%r10,%rdi,8),%xmm0
mulsd  %xmm1,%xmm0
or     $0x3,%rcx
lea    (%rcx,%r14,1),%rdi
mov    0x40(%rsp),%r11
movsd  %xmm0,(%r8,%rdi,8)
movsd  -0x40(%r15),%xmm0
mulsd  %xmm2,%xmm0
movsd  %xmm0,0x20(%r12)
lea    (%rax,%r11,1),%rdi
movsd  (%r10,%rdi,8),%xmm0
mulsd  %xmm2,%xmm0
lea    (%rbx,%r11,1),%rdi
movsd  %xmm0,(%r8,%rdi,8)
lea    0x0(%rbp,%r11,1),%rdi
movsd  (%r10,%rdi,8),%xmm0
mulsd  %xmm2,%xmm0
lea    (%rdx,%r11,1),%rdi
movsd  %xmm0,(%r8,%rdi,8)
lea    (%rsi,%r11,1),%rdi
movsd  (%r10,%rdi,8),%xmm0
mulsd  %xmm2,%xmm0
lea    (%rcx,%r11,1),%rdi
movsd  %xmm0,(%r8,%rdi,8)
movsd  -0x20(%r15),%xmm0
mulsd  %xmm3,%xmm0
movsd  %xmm0,0x40(%r12)
mov    %r9,%r14
mov    0x30(%rsp),%r9
lea    (%rax,%r9,1),%rdi
movsd  (%r10,%rdi,8),%xmm0
mulsd  %xmm3,%xmm0
lea    (%rbx,%r9,1),%rdi
movsd  %xmm0,(%r8,%rdi,8)
lea    0x0(%rbp,%r9,1),%rdi
movsd  (%r10,%rdi,8),%xmm0
mulsd  %xmm3,%xmm0
lea    (%rdx,%r9,1),%rdi
movsd  %xmm0,(%r8,%rdi,8)
lea    (%rsi,%r9,1),%rdi
movsd  (%r10,%rdi,8),%xmm0
mulsd  %xmm3,%xmm0
lea    (%rcx,%r9,1),%rdi
mov    %r14,%r9
movsd  %xmm0,(%r8,%rdi,8)
mov    %r13,%rdi
movsd  (%r15),%xmm0
mulsd  %xmm4,%xmm0
movsd  %xmm0,0x60(%r12)
add    %r13,%rax
movsd  (%r10,%rax,8),%xmm0
mulsd  %xmm4,%xmm0
add    %r13,%rbx
movsd  %xmm0,(%r8,%rbx,8)
mov    0x28(%rsp),%rax
add    %r13,%rbp
movsd  (%r10,%rbp,8),%xmm0
mov    0xb8(%rsp),%rbx
mulsd  %xmm4,%xmm0
add    %r13,%rdx
movsd  %xmm0,(%r8,%rdx,8)
mov    0x38(%rsp),%r14
add    %r13,%rsi
movsd  (%r10,%rsi,8),%xmm0
mov    0x18(%rsp),%r13
mulsd  %xmm4,%xmm0
add    %rdi,%rcx
movsd  %xmm0,(%r8,%rcx,8)
mov    0x10(%rsp),%rsi
mov    0xe8(%rsp),%r8
add    $0x4,%r13
add    %rax,%r9
mov    0xc0(%rsp),%rax
add    %rax,%r15
add    %rbx,%rsi
add    %r14,%r12
cmp    %r8,%r13
jl     1610 <dpotrf_diag_lib+0x500>
jmp    1240 <dpotrf_diag_lib+0x130>
mov    0xf0(%rsp),%rsi
mov    %esi,%eax
sub    %edx,%eax
test   %eax,%eax
jle    1e2a <dpotrf_diag_lib+0xd1a>
mov    %edx,%ecx
mov    0x58(%rsp),%r8
imul   %r8d,%ecx
mov    %rcx,0xb0(%rsp)
cmp    $0x4,%eax
mov    $0x4,%ebx
cmovb  %eax,%ebx
lea    0x3(%rsi),%edi
test   %esi,%esi
cmovns %esi,%edi
and    $0xfffffffc,%edi
add    $0x4,%edi
lea    0x4(%rdx),%esi
mov    %edx,%ecx
mov    %rcx,0xe0(%rsp)
add    $0x4,%rcx
mov    %edi,0xa8(%rsp)
movslq %edi,%rdi
mov    %rdi,0x98(%rsp)
mov    %eax,%eax
mov    %rax,0x90(%rsp)
lea    -0x2(%rbx),%rax
mov    %rax,0xd0(%rsp)
lea    0x4(%r8),%ebp
imul   %edx,%ebp
lea    0x1(%rbp),%edi
mov    %rbx,0x78(%rsp)
lea    -0x5(%rbx),%rax
mov    %rax,0x50(%rsp)
mov    0x70(%rsp),%rbx
mov    %ebx,%eax
mov    %esi,0xa0(%rsp)
imul   %esi,%eax
lea    (%rax,%rdx,4),%eax
add    $0x3,%eax
mov    %eax,0xc0(%rsp)
imul   %rbx,%rcx
mov    (%rsp),%rax
lea    (%rax,%rcx,8),%rax
mov    %rax,0xd8(%rsp)
mov    %rbx,%rax
shl    $0x5,%rax
mov    %rax,0xb8(%rsp)
mov    %r8,%rax
shl    $0x5,%rax
mov    %rax,0x88(%rsp)
xorpd  %xmm2,%xmm2
movsd  0x703(%rip),%xmm3
xorpd  %xmm4,%xmm4
lea    0x0(,%rdx,4),%r13d
lea    0x0(,%rbx,4),%r15d
lea    0x0(,%r8,4),%eax
mov    %eax,0x80(%rsp)
mov    $0x1,%r11d
xor    %eax,%eax
mov    %rax,0x18(%rsp)
mov    %r13d,%eax
mov    %r13d,0x40(%rsp)
mov    %edi,0xc8(%rsp)
mov    %edi,0x48(%rsp)
mov    %rbp,0x38(%rsp)
xor    %ebx,%ebx
mov    %rdx,0x20(%rsp)
jmp    19a5 <dpotrf_diag_lib+0x895>
xchg   %ax,%ax
mov    0x10(%rsp),%r11
add    $0x1,%r11
addq   $0x5,0x38(%rsp)
addq   $0xffffffffffffffff,0x50(%rsp)
addl   $0x5,0x48(%rsp)
mov    0x8(%rsp),%rbp
add    $0x4,%rbp
addl   $0x4,0xc0(%rsp)
04
addl   $0x4,0x40(%rsp)
mov    0x18(%rsp),%rax
add    $0x4,%eax
mov    %rax,0x18(%rsp)
mov    0x30(%rsp),%rbx
cmp    0x90(%rsp),%rbx
mov    0x20(%rsp),%rdx
je     1e2a <dpotrf_diag_lib+0xd1a>
lea    (%rdx,%rbx,1),%eax
mov    0xb0(%rsp),%rcx
lea    (%rcx,%rax,4),%ecx
mov    %rcx,%rax
mov    %rcx,0x28(%rsp)
lea    (%rcx,%rbx,1),%eax
movslq %eax,%r12
movsd  (%r10,%r12,8),%xmm0
ucomisd %xmm2,%xmm0
mov    %r11,0x10(%rsp)
jb     19e0 <dpotrf_diag_lib+0x8d0>
sqrtsd %xmm0,%xmm0
jmp    19ff <dpotrf_diag_lib+0x8ef>
nopl   0x0(%rax,%rax,1)
call   1030 <sqrt@plt>
mov    0x10(%rsp),%r11
xorpd  %xmm4,%xmm4
movsd  0x60a(%rip),%xmm3
xorpd  %xmm2,%xmm2
mov    0x60(%rsp),%r10
mov    0x78(%rsp),%rax
movapd %xmm3,%xmm1
divsd  %xmm0,%xmm1
mov    (%rsp),%rcx
movsd  %xmm1,(%rcx,%r12,8)
lea    0x1(%rbx),%rcx
mov    %ecx,%esi
mov    %rcx,0x30(%rsp)
cmp    %rax,%rcx
mov    0x20(%rsp),%r9
mov    0x98(%rsp),%r8
mov    0x38(%rsp),%rdi
mov    %rbp,0x8(%rsp)
jae    1c08 <dpotrf_diag_lib+0xaf8>
mov    %rbx,%rsi
not    %rsi
lea    (%rsi,%rax,1),%rbp
mov    %r11,%rcx
cmp    $0x4,%rbp
jb     1b70 <dpotrf_diag_lib+0xa60>
mov    0xd0(%rsp),%rdx
sub    %rbx,%rdx
lea    (%rbx,%rbx,4),%ebx
add    0xc8(%rsp),%ebx
lea    (%rdx,%rbx,1),%r12d
mov    %r11,%rcx
cmp    %ebx,%r12d
jl     1b70 <dpotrf_diag_lib+0xa60>
shr    $0x20,%rdx
mov    %r11,%rcx
jne    1b70 <dpotrf_diag_lib+0xa60>
mov    0x50(%rsp),%r12
shr    $0x2,%r12
lea    (%rsi,%rax,1),%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,%rbx
shr    $0x2,%rbx
add    $0x1,%rbx
cmp    $0xc,%rcx
jae    1ab0 <dpotrf_diag_lib+0x9a0>
xor    %esi,%esi
jmp    1b20 <dpotrf_diag_lib+0xa10>
lea    0x1(%r12),%rcx
and    $0xfffffffffffffffc,%rcx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
lea    (%rdi,%rsi,1),%edx
add    $0x1,%edx
movslq %edx,%rdx
mov    (%rsp),%r14
movupd %xmm4,(%r14,%rdx,8)
movupd %xmm4,0x10(%r14,%rdx,8)
lea    0x5(%rdi,%rsi,1),%edx
movslq %edx,%rdx
movupd %xmm4,(%r14,%rdx,8)
movupd %xmm4,0x10(%r14,%rdx,8)
lea    0x9(%rdi,%rsi,1),%edx
movslq %edx,%rdx
movupd %xmm4,(%r14,%rdx,8)
movupd %xmm4,0x10(%r14,%rdx,8)
lea    0xd(%rdi,%rsi,1),%edx
movslq %edx,%rdx
movupd %xmm4,(%r14,%rdx,8)
movupd %xmm4,0x10(%r14,%rdx,8)
add    $0x10,%rsi
add    $0xfffffffffffffffc,%rcx
jne    1ac0 <dpotrf_diag_lib+0x9b0>
mov    %rbp,%rcx
and    $0xfffffffffffffffc,%rcx
test   $0x3,%bl
je     1b5b <dpotrf_diag_lib+0xa4b>
add    $0x1,%r12b
movzbl %r12b,%edi
and    $0x3,%edi
add    0x48(%rsp),%esi
nopl   0x0(%rax,%rax,1)
movslq %esi,%rsi
mov    (%rsp),%rdx
movupd %xmm4,(%rdx,%rsi,8)
movupd %xmm4,0x10(%rdx,%rsi,8)
add    $0x4,%esi
add    $0xffffffffffffffff,%rdi
jne    1b40 <dpotrf_diag_lib+0xa30>
mov    %eax,%esi
cmp    %rcx,%rbp
je     1c08 <dpotrf_diag_lib+0xaf8>
add    %r11,%rcx
nopl   0x0(%rax)
mov    %eax,%esi
sub    %ecx,%esi
mov    %rcx,%rdx
not    %rdx
add    %rax,%rdx
and    $0x3,%rsi
je     1bad <dpotrf_diag_lib+0xa9d>
neg    %rsi
mov    0x8(%rsp),%rbp
nopl   0x0(%rax,%rax,1)
lea    (%rcx,%rbp,1),%edi
movslq %edi,%rdi
mov    (%rsp),%rbx
movq   $0x0,(%rbx,%rdi,8)
add    $0x1,%rcx
inc    %rsi
jne    1b90 <dpotrf_diag_lib+0xa80>
jmp    1bb2 <dpotrf_diag_lib+0xaa2>
mov    0x8(%rsp),%rbp
mov    %eax,%esi
cmp    $0x3,%rdx
jb     1c08 <dpotrf_diag_lib+0xaf8>
nopw   0x0(%rax,%rax,1)
lea    (%rcx,%rbp,1),%rdx
movslq %edx,%rdx
mov    (%rsp),%rdi
movq   $0x0,(%rdi,%rdx,8)
lea    0x1(%rdx),%esi
movslq %esi,%rsi
movq   $0x0,(%rdi,%rsi,8)
lea    0x2(%rdx),%esi
movslq %esi,%rsi
movq   $0x0,(%rdi,%rsi,8)
add    $0x3,%edx
movslq %edx,%rdx
movq   $0x0,(%rdi,%rdx,8)
add    $0x4,%rcx
cmp    %rcx,%rax
jne    1bc0 <dpotrf_diag_lib+0xab0>
mov    %eax,%esi
cmp    $0x4,%esi
jae    1cb0 <dpotrf_diag_lib+0xba0>
mov    0x28(%rsp),%rax
lea    (%rax,%rsi,1),%ecx
movslq %ecx,%rcx
movsd  (%r10,%rcx,8),%xmm0
mulsd  %xmm1,%xmm0
mov    (%rsp),%rax
movsd  %xmm0,(%rax,%rcx,8)
cmp    $0x2,%esi
ja     1cb0 <dpotrf_diag_lib+0xba0>
lea    0x1(%rsi),%ecx
mov    0x28(%rsp),%rax
lea    (%rax,%rsi,1),%edx
add    $0x1,%edx
movslq %edx,%rdx
movsd  (%r10,%rdx,8),%xmm0
mulsd  %xmm1,%xmm0
mov    (%rsp),%rax
movsd  %xmm0,(%rax,%rdx,8)
cmp    $0x2,%ecx
ja     1cb0 <dpotrf_diag_lib+0xba0>
lea    0x2(%rsi),%ecx
mov    0x28(%rsp),%rax
lea    (%rax,%rsi,1),%edx
add    $0x2,%edx
movslq %edx,%rdx
movsd  (%r10,%rdx,8),%xmm0
mulsd  %xmm1,%xmm0
mov    (%rsp),%rax
movsd  %xmm0,(%rax,%rdx,8)
cmp    $0x2,%ecx
ja     1cb0 <dpotrf_diag_lib+0xba0>
mov    0x28(%rsp),%rax
lea    (%rsi,%rax,1),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%r10,%rcx,8),%xmm0
mulsd  %xmm1,%xmm0
mov    (%rsp),%rax
movsd  %xmm0,(%rax,%rcx,8)
nopl   0x0(%rax,%rax,1)
movslq 0x40(%rsp),%rbx
mov    0xa0(%rsp),%eax
mov    %eax,%ecx
cmp    0xa8(%rsp),%r9d
jge    1d35 <dpotrf_diag_lib+0xc25>
mov    0xd8(%rsp),%rax
lea    (%rax,%rbx,8),%rdx
mov    0xc0(%rsp),%eax
mov    %eax,%esi
mov    0xe0(%rsp),%rcx
mov    0xb8(%rsp),%rdi
nopl   (%rax)
movq   $0x0,(%rdx)
lea    -0x2(%rsi),%eax
cltq
mov    (%rsp),%rbp
movq   $0x0,0x0(%rbp,%rax,8)
lea    -0x1(%rsi),%eax
cltq
movq   $0x0,0x0(%rbp,%rax,8)
movslq %esi,%rsi
movq   $0x0,0x0(%rbp,%rsi,8)
add    $0x4,%rcx
add    %r15d,%esi
add    %rdi,%rdx
cmp    %r8,%rcx
jl     1cf0 <dpotrf_diag_lib+0xbe0>
add    $0x4,%ecx
cmp    0x6c(%rsp),%ecx
mov    0xb8(%rsp),%r9
mov    0x88(%rsp),%r12
mov    0x80(%rsp),%r11d
mov    0xe8(%rsp),%r8
jge    1950 <dpotrf_diag_lib+0x840>
movslq %ecx,%r14
mov    0x70(%rsp),%rdi
mov    %edi,%esi
imul   %ecx,%esi
mov    0x18(%rsp),%rbp
add    %ebp,%esi
imul   %r14,%rdi
add    %rbx,%rdi
mov    (%rsp),%rax
lea    (%rax,%rdi,8),%rdi
mov    0x58(%rsp),%rax
imul   %eax,%ecx
add    %ebp,%ecx
imul   %r14,%rax
add    %rbx,%rax
lea    (%r10,%rax,8),%rbx
nopw   0x0(%rax,%rax,1)
movsd  (%rbx),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,(%rdi)
lea    (%rcx,%r13,1),%eax
add    $0x1,%eax
cltq
movsd  (%r10,%rax,8),%xmm0
mulsd  %xmm1,%xmm0
lea    0x1(%r13,%rsi,1),%eax
cltq
mov    (%rsp),%rdx
movsd  %xmm0,(%rdx,%rax,8)
lea    0x2(%r13,%rcx,1),%eax
cltq
movsd  (%r10,%rax,8),%xmm0
mulsd  %xmm1,%xmm0
lea    0x2(%r13,%rsi,1),%eax
cltq
lea    0x3(%r13,%rcx,1),%ebp
movsd  %xmm0,(%rdx,%rax,8)
movslq %ebp,%rax
movsd  (%r10,%rax,8),%xmm0
mulsd  %xmm1,%xmm0
lea    (%rsi,%r13,1),%eax
add    $0x3,%eax
cltq
add    $0x4,%r14
add    %r15d,%esi
movsd  %xmm0,(%rdx,%rax,8)
add    %r9,%rdi
add    %r11d,%ecx
add    %r12,%rbx
cmp    %r8,%r14
jl     1da0 <dpotrf_diag_lib+0xc90>
jmp    1950 <dpotrf_diag_lib+0x840>
add    $0x108,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @dpotrf_diag_lib(i32 %0, i32 %1, double* %2, i32 %3, double* writeonly %4, i32 %5) {
%7 = icmp sgt i32 %1, 3
br i1 %7, label %8, label %21
8: ; preds = %6
%9 = add nsw i32 %1, -3
%10 = and i32 %1, -4
%11 = sext i32 %5 to i64
%12 = zext i32 %10 to i64
%13 = sext i32 %3 to i64
%14 = sext i32 %0 to i64
%15 = zext i32 %9 to i64
br label %47
16: ; preds = %151, %99
%17 = icmp ult i64 %97, %15
%18 = add nuw nsw i64 %49, 4
br i1 %17, label %47, label %19
19: ; preds = %16
%20 = trunc i64 %97 to i32
br label %21
21: ; preds = %19, %6
%22 = phi i32 [ 0, %6 ], [ %20, %19 ]
%23 = sub i32 %1, %22
%24 = icmp sgt i32 %23, 0
br i1 %24, label %25, label %529
25: ; preds = %21
%26 = mul nsw i32 %22, %3
%27 = icmp ult i32 %23, 4
%28 = select i1 %27, i32 %23, i32 4
%29 = sdiv i32 %1, 4
%30 = shl nsw i32 %29, 2
%31 = add nsw i32 %30, 4
%32 = add nuw nsw i32 %22, 4
%33 = icmp slt i32 %22, %31
%34 = zext i32 %22 to i64
%35 = add nuw nsw i64 %34, 4
%36 = sext i32 %5 to i64
%37 = sext i32 %31 to i64
%38 = sext i32 %3 to i64
%39 = sext i32 %0 to i64
%40 = zext i32 %28 to i64
%41 = zext i32 %23 to i64
%42 = zext i32 %28 to i64
%43 = add nsw i64 %42, -2
%44 = add i32 %3, 4
%45 = mul i32 %22, %44
%46 = add i32 %45, 1
br label %274
47: ; preds = %8, %16
%48 = phi i64 [ 0, %8 ], [ %97, %16 ]
%49 = phi i64 [ 4, %8 ], [ %18, %16 ]
%50 = trunc i64 %48 to i32
%51 = mul nsw i64 %48, %13
%52 = mul nsw i32 %50, %3
%53 = shl nsw i64 %48, 2
%54 = add nsw i64 %51, %53
%55 = getelementptr inbounds double, double* %2, i64 %54
%56 = load double, double* %55
%57 = tail call double @sqrt(double %56)
%58 = fdiv double 1.000000e+00, %57
%59 = or i32 %52, 1
%60 = or i64 %53, 4
%61 = sext i32 %59 to i64
%62 = add nsw i64 %60, %61
%63 = getelementptr inbounds double, double* %2, i64 %62
%64 = load double, double* %63
%65 = tail call double @sqrt(double %64)
%66 = fdiv double 1.000000e+00, %65
%67 = or i32 %52, 2
%68 = or i64 %53, 8
%69 = sext i32 %67 to i64
%70 = add nsw i64 %68, %69
%71 = getelementptr inbounds double, double* %2, i64 %70
%72 = load double, double* %71
%73 = tail call double @sqrt(double %72)
%74 = fdiv double 1.000000e+00, %73
%75 = or i32 %52, 3
%76 = or i64 %53, 12
%77 = sext i32 %75 to i64
%78 = add nsw i64 %76, %77
%79 = getelementptr inbounds double, double* %2, i64 %78
%80 = load double, double* %79
%81 = tail call double @sqrt(double %80)
%82 = fdiv double 1.000000e+00, %81
%83 = getelementptr inbounds double, double* %4, i64 %54
store double %58, double* %83
%84 = add nsw i64 %53, %61
%85 = getelementptr inbounds double, double* %4, i64 %84
%86 = bitcast double* %85 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %86
%87 = add nsw i64 %53, %77
%88 = getelementptr inbounds double, double* %4, i64 %87
store double 0.000000e+00, double* %88
%89 = getelementptr inbounds double, double* %4, i64 %62
store double %66, double* %89
%90 = add nsw i64 %60, %69
%91 = getelementptr inbounds double, double* %4, i64 %90
%92 = bitcast double* %91 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %92
%93 = getelementptr inbounds double, double* %4, i64 %70
store double %74, double* %93
%94 = add nsw i64 %68, %77
%95 = getelementptr inbounds double, double* %4, i64 %94
store double 0.000000e+00, double* %95
%96 = getelementptr inbounds double, double* %4, i64 %78
store double %82, double* %96
%97 = add nuw nsw i64 %48, 4
%98 = icmp ult i64 %97, %12
br i1 %98, label %106, label %99
99: ; preds = %106, %47
%100 = phi i64 [ %97, %47 ], [ %149, %106 ]
%101 = trunc i64 %100 to i32
%102 = icmp slt i32 %101, %0
br i1 %102, label %103, label %16
103: ; preds = %99
%104 = shl i64 %100, 32
%105 = ashr exact i64 %104, 32
br label %151
106: ; preds = %47, %106
%107 = phi i64 [ %149, %106 ], [ %49, %47 ]
%108 = trunc i64 %107 to i32
%109 = mul nsw i64 %107, %11
%110 = mul nsw i32 %108, %5
%111 = add nsw i64 %109, %53
%112 = getelementptr inbounds double, double* %4, i64 %111
store double 0.000000e+00, double* %112
%113 = or i32 %110, 1
%114 = sext i32 %113 to i64
%115 = add nsw i64 %53, %114
%116 = getelementptr inbounds double, double* %4, i64 %115
store double 0.000000e+00, double* %116
%117 = or i32 %110, 2
%118 = sext i32 %117 to i64
%119 = add nsw i64 %53, %118
%120 = getelementptr inbounds double, double* %4, i64 %119
store double 0.000000e+00, double* %120
%121 = or i32 %110, 3
%122 = sext i32 %121 to i64
%123 = add nsw i64 %53, %122
%124 = getelementptr inbounds double, double* %4, i64 %123
store double 0.000000e+00, double* %124
%125 = add nsw i64 %109, %60
%126 = getelementptr inbounds double, double* %4, i64 %125
store double 0.000000e+00, double* %126
%127 = add nsw i64 %60, %114
%128 = getelementptr inbounds double, double* %4, i64 %127
store double 0.000000e+00, double* %128
%129 = add nsw i64 %60, %118
%130 = getelementptr inbounds double, double* %4, i64 %129
store double 0.000000e+00, double* %130
%131 = add nsw i64 %60, %122
%132 = getelementptr inbounds double, double* %4, i64 %131
store double 0.000000e+00, double* %132
%133 = add nsw i64 %109, %68
%134 = getelementptr inbounds double, double* %4, i64 %133
store double 0.000000e+00, double* %134
%135 = add nsw i64 %68, %114
%136 = getelementptr inbounds double, double* %4, i64 %135
store double 0.000000e+00, double* %136
%137 = add nsw i64 %68, %118
%138 = getelementptr inbounds double, double* %4, i64 %137
store double 0.000000e+00, double* %138
%139 = add nsw i64 %68, %122
%140 = getelementptr inbounds double, double* %4, i64 %139
store double 0.000000e+00, double* %140
%141 = add nsw i64 %109, %76
%142 = getelementptr inbounds double, double* %4, i64 %141
store double 0.000000e+00, double* %142
%143 = add nsw i64 %76, %114
%144 = getelementptr inbounds double, double* %4, i64 %143
store double 0.000000e+00, double* %144
%145 = add nsw i64 %76, %118
%146 = getelementptr inbounds double, double* %4, i64 %145
store double 0.000000e+00, double* %146
%147 = add nsw i64 %76, %122
%148 = getelementptr inbounds double, double* %4, i64 %147
store double 0.000000e+00, double* %148
%149 = add nuw nsw i64 %107, 4
%150 = icmp ult i64 %149, %12
br i1 %150, label %106, label %99
151: ; preds = %103, %151
%152 = phi i64 [ %105, %103 ], [ %269, %151 ]
%153 = mul nsw i64 %152, %13
%154 = add nsw i64 %153, %53
%155 = getelementptr inbounds double, double* %2, i64 %154
%156 = load double, double* %155
%157 = fmul double %58, %156
%158 = mul nsw i64 %152, %11
%159 = add nsw i64 %158, %53
%160 = getelementptr inbounds double, double* %4, i64 %159
store double %157, double* %160
%161 = shl i64 %153, 32
%162 = ashr exact i64 %161, 32
%163 = or i64 %162, 1
%164 = add nsw i64 %163, %53
%165 = getelementptr inbounds double, double* %2, i64 %164
%166 = load double, double* %165
%167 = fmul double %58, %166
%168 = shl i64 %158, 32
%169 = ashr exact i64 %168, 32
%170 = or i64 %169, 1
%171 = add nsw i64 %170, %53
%172 = getelementptr inbounds double, double* %4, i64 %171
store double %167, double* %172
%173 = shl i64 %153, 32
%174 = ashr exact i64 %173, 32
%175 = or i64 %174, 2
%176 = add nsw i64 %175, %53
%177 = getelementptr inbounds double, double* %2, i64 %176
%178 = load double, double* %177
%179 = fmul double %58, %178
%180 = shl i64 %158, 32
%181 = ashr exact i64 %180, 32
%182 = or i64 %181, 2
%183 = add nsw i64 %182, %53
%184 = getelementptr inbounds double, double* %4, i64 %183
store double %179, double* %184
%185 = shl i64 %153, 32
%186 = ashr exact i64 %185, 32
%187 = or i64 %186, 3
%188 = add nsw i64 %187, %53
%189 = getelementptr inbounds double, double* %2, i64 %188
%190 = load double, double* %189
%191 = fmul double %58, %190
%192 = shl i64 %158, 32
%193 = ashr exact i64 %192, 32
%194 = or i64 %193, 3
%195 = add nsw i64 %194, %53
%196 = getelementptr inbounds double, double* %4, i64 %195
store double %191, double* %196
%197 = add nsw i64 %153, %60
%198 = getelementptr inbounds double, double* %2, i64 %197
%199 = load double, double* %198
%200 = fmul double %66, %199
%201 = add nsw i64 %158, %60
%202 = getelementptr inbounds double, double* %4, i64 %201
store double %200, double* %202
%203 = add nsw i64 %163, %60
%204 = getelementptr inbounds double, double* %2, i64 %203
%205 = load double, double* %204
%206 = fmul double %66, %205
%207 = add nsw i64 %170, %60
%208 = getelementptr inbounds double, double* %4, i64 %207
store double %206, double* %208
%209 = add nsw i64 %175, %60
%210 = getelementptr inbounds double, double* %2, i64 %209
%211 = load double, double* %210
%212 = fmul double %66, %211
%213 = add nsw i64 %182, %60
%214 = getelementptr inbounds double, double* %4, i64 %213
store double %212, double* %214
%215 = add nsw i64 %187, %60
%216 = getelementptr inbounds double, double* %2, i64 %215
%217 = load double, double* %216
%218 = fmul double %66, %217
%219 = add nsw i64 %194, %60
%220 = getelementptr inbounds double, double* %4, i64 %219
store double %218, double* %220
%221 = add nsw i64 %153, %68
%222 = getelementptr inbounds double, double* %2, i64 %221
%223 = load double, double* %222
%224 = fmul double %74, %223
%225 = add nsw i64 %158, %68
%226 = getelementptr inbounds double, double* %4, i64 %225
store double %224, double* %226
%227 = add nsw i64 %163, %68
%228 = getelementptr inbounds double, double* %2, i64 %227
%229 = load double, double* %228
%230 = fmul double %74, %229
%231 = add nsw i64 %170, %68
%232 = getelementptr inbounds double, double* %4, i64 %231
store double %230, double* %232
%233 = add nsw i64 %175, %68
%234 = getelementptr inbounds double, double* %2, i64 %233
%235 = load double, double* %234
%236 = fmul double %74, %235
%237 = add nsw i64 %182, %68
%238 = getelementptr inbounds double, double* %4, i64 %237
store double %236, double* %238
%239 = add nsw i64 %187, %68
%240 = getelementptr inbounds double, double* %2, i64 %239
%241 = load double, double* %240
%242 = fmul double %74, %241
%243 = add nsw i64 %194, %68
%244 = getelementptr inbounds double, double* %4, i64 %243
store double %242, double* %244
%245 = add nsw i64 %153, %76
%246 = getelementptr inbounds double, double* %2, i64 %245
%247 = load double, double* %246
%248 = fmul double %82, %247
%249 = add nsw i64 %158, %76
%250 = getelementptr inbounds double, double* %4, i64 %249
store double %248, double* %250
%251 = add nsw i64 %163, %76
%252 = getelementptr inbounds double, double* %2, i64 %251
%253 = load double, double* %252
%254 = fmul double %82, %253
%255 = add nsw i64 %170, %76
%256 = getelementptr inbounds double, double* %4, i64 %255
store double %254, double* %256
%257 = add nsw i64 %175, %76
%258 = getelementptr inbounds double, double* %2, i64 %257
%259 = load double, double* %258
%260 = fmul double %82, %259
%261 = add nsw i64 %182, %76
%262 = getelementptr inbounds double, double* %4, i64 %261
store double %260, double* %262
%263 = add nsw i64 %187, %76
%264 = getelementptr inbounds double, double* %2, i64 %263
%265 = load double, double* %264
%266 = fmul double %82, %265
%267 = add nsw i64 %194, %76
%268 = getelementptr inbounds double, double* %4, i64 %267
store double %266, double* %268
%269 = add nsw i64 %152, 4
%270 = icmp slt i64 %269, %14
br i1 %270, label %151, label %16
271: ; preds = %491, %465
%272 = add nuw nsw i64 %276, 1
%273 = icmp eq i64 %299, %41
br i1 %273, label %529, label %274
274: ; preds = %25, %271
%275 = phi i64 [ 0, %25 ], [ %299, %271 ]
%276 = phi i64 [ 1, %25 ], [ %272, %271 ]
%277 = xor i64 %275, -1
%278 = add nsw i64 %277, %42
%279 = add i64 %278, -4
%280 = lshr i64 %279, 2
%281 = add nuw nsw i64 %280, 1
%282 = xor i64 %275, -1
%283 = add nsw i64 %282, %42
%284 = sub i64 %43, %275
%285 = trunc i64 %275 to i32
%286 = mul i32 %285, 5
%287 = add i32 %286, %46
%288 = trunc i64 %275 to i32
%289 = add nuw nsw i32 %22, %288
%290 = shl nsw i32 %289, 2
%291 = add i32 %290, %26
%292 = add i32 %291, %288
%293 = sext i32 %292 to i64
%294 = getelementptr inbounds double, double* %2, i64 %293
%295 = load double, double* %294
%296 = tail call double @sqrt(double %295)
%297 = fdiv double 1.000000e+00, %296
%298 = getelementptr inbounds double, double* %4, i64 %293
store double %297, double* %298
%299 = add nuw nsw i64 %275, 1
%300 = icmp ult i64 %299, %40
%301 = trunc i64 %299 to i32
br i1 %300, label %302, label %397
302: ; preds = %274
%303 = icmp ult i64 %283, 4
br i1 %303, label %377, label %304
304: ; preds = %302
%305 = trunc i64 %284 to i32
%306 = add i32 %287, %305
%307 = icmp slt i32 %306, %287
%308 = icmp ugt i64 %284, 4294967295
%309 = or i1 %307, %308
br i1 %309, label %377, label %310
310: ; preds = %304
%311 = and i64 %283, -4
%312 = add i64 %276, %311
%313 = and i64 %281, 3
%314 = icmp ult i64 %279, 12
br i1 %314, label %358, label %315
315: ; preds = %310
%316 = and i64 %281, 9223372036854775804
br label %317
317: ; preds = %317, %315
%318 = phi i64 [ 0, %315 ], [ %355, %317 ]
%319 = phi i64 [ 0, %315 ], [ %356, %317 ]
%320 = add i64 %276, %318
%321 = trunc i64 %320 to i32
%322 = add i32 %291, %321
%323 = sext i32 %322 to i64
%324 = getelementptr inbounds double, double* %4, i64 %323
%325 = bitcast double* %324 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %325
%326 = getelementptr inbounds double, double* %324, i64 2
%327 = bitcast double* %326 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %327
%328 = or i64 %318, 4
%329 = add i64 %276, %328
%330 = trunc i64 %329 to i32
%331 = add i32 %291, %330
%332 = sext i32 %331 to i64
%333 = getelementptr inbounds double, double* %4, i64 %332
%334 = bitcast double* %333 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %334
%335 = getelementptr inbounds double, double* %333, i64 2
%336 = bitcast double* %335 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %336
%337 = or i64 %318, 8
%338 = add i64 %276, %337
%339 = trunc i64 %338 to i32
%340 = add i32 %291, %339
%341 = sext i32 %340 to i64
%342 = getelementptr inbounds double, double* %4, i64 %341
%343 = bitcast double* %342 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %343
%344 = getelementptr inbounds double, double* %342, i64 2
%345 = bitcast double* %344 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %345
%346 = or i64 %318, 12
%347 = add i64 %276, %346
%348 = trunc i64 %347 to i32
%349 = add i32 %291, %348
%350 = sext i32 %349 to i64
%351 = getelementptr inbounds double, double* %4, i64 %350
%352 = bitcast double* %351 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %352
%353 = getelementptr inbounds double, double* %351, i64 2
%354 = bitcast double* %353 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %354
%355 = add nuw i64 %318, 16
%356 = add nuw i64 %319, 4
%357 = icmp eq i64 %356, %316
br i1 %357, label %358, label %317
358: ; preds = %317, %310
%359 = phi i64 [ 0, %310 ], [ %355, %317 ]
%360 = icmp eq i64 %313, 0
br i1 %360, label %375, label %361
361: ; preds = %358, %361
%362 = phi i64 [ %372, %361 ], [ %359, %358 ]
%363 = phi i64 [ %373, %361 ], [ 0, %358 ]
%364 = add i64 %276, %362
%365 = trunc i64 %364 to i32
%366 = add i32 %291, %365
%367 = sext i32 %366 to i64
%368 = getelementptr inbounds double, double* %4, i64 %367
%369 = bitcast double* %368 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %369
%370 = getelementptr inbounds double, double* %368, i64 2
%371 = bitcast double* %370 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %371
%372 = add nuw i64 %362, 4
%373 = add i64 %363, 1
%374 = icmp eq i64 %373, %313
br i1 %374, label %375, label %361
375: ; preds = %361, %358
%376 = icmp eq i64 %283, %311
br i1 %376, label %397, label %377
377: ; preds = %304, %302, %375
%378 = phi i64 [ %276, %304 ], [ %276, %302 ], [ %312, %375 ]
%379 = sub i64 %42, %378
%380 = xor i64 %378, -1
%381 = add i64 %380, %42
%382 = and i64 %379, 3
%383 = icmp eq i64 %382, 0
br i1 %383, label %394, label %384
384: ; preds = %377, %384
%385 = phi i64 [ %391, %384 ], [ %378, %377 ]
%386 = phi i64 [ %392, %384 ], [ 0, %377 ]
%387 = trunc i64 %385 to i32
%388 = add i32 %291, %387
%389 = sext i32 %388 to i64
%390 = getelementptr inbounds double, double* %4, i64 %389
store double 0.000000e+00, double* %390
%391 = add nuw nsw i64 %385, 1
%392 = add i64 %386, 1
%393 = icmp eq i64 %392, %382
br i1 %393, label %394, label %384
394: ; preds = %384, %377
%395 = phi i64 [ %378, %377 ], [ %391, %384 ]
%396 = icmp ult i64 %381, 3
br i1 %396, label %397, label %400
397: ; preds = %394, %400, %375, %274
%398 = phi i32 [ %301, %274 ], [ %28, %375 ], [ %28, %400 ], [ %28, %394 ]
%399 = icmp ult i32 %398, 4
br i1 %399, label %429, label %423
400: ; preds = %394, %400
%401 = phi i64 [ %421, %400 ], [ %395, %394 ]
%402 = trunc i64 %401 to i32
%403 = add i32 %291, %402
%404 = sext i32 %403 to i64
%405 = getelementptr inbounds double, double* %4, i64 %404
store double 0.000000e+00, double* %405
%406 = trunc i64 %401 to i32
%407 = add i32 %406, 1
%408 = add i32 %291, %407
%409 = sext i32 %408 to i64
%410 = getelementptr inbounds double, double* %4, i64 %409
store double 0.000000e+00, double* %410
%411 = trunc i64 %401 to i32
%412 = add i32 %411, 2
%413 = add i32 %291, %412
%414 = sext i32 %413 to i64
%415 = getelementptr inbounds double, double* %4, i64 %414
store double 0.000000e+00, double* %415
%416 = trunc i64 %401 to i32
%417 = add i32 %416, 3
%418 = add i32 %291, %417
%419 = sext i32 %418 to i64
%420 = getelementptr inbounds double, double* %4, i64 %419
store double 0.000000e+00, double* %420
%421 = add nuw nsw i64 %401, 4
%422 = icmp eq i64 %421, %42
br i1 %422, label %397, label %400
423: ; preds = %429, %437, %446, %455, %397
br i1 %33, label %424, label %465
424: ; preds = %423
%425 = or i32 %290, 1
%426 = or i32 %290, 2
%427 = or i32 %290, 3
%428 = sext i32 %290 to i64
br label %474
429: ; preds = %397
%430 = add i32 %291, %398
%431 = sext i32 %430 to i64
%432 = getelementptr inbounds double, double* %2, i64 %431
%433 = load double, double* %432
%434 = fmul double %297, %433
%435 = getelementptr inbounds double, double* %4, i64 %431
store double %434, double* %435
%436 = icmp ult i32 %398, 3
br i1 %436, label %437, label %423
437: ; preds = %429
%438 = add i32 %398, 1
%439 = add i32 %291, %438
%440 = sext i32 %439 to i64
%441 = getelementptr inbounds double, double* %2, i64 %440
%442 = load double, double* %441
%443 = fmul double %297, %442
%444 = getelementptr inbounds double, double* %4, i64 %440
store double %443, double* %444
%445 = icmp ult i32 %438, 3
br i1 %445, label %446, label %423
446: ; preds = %437
%447 = add i32 %398, 2
%448 = add i32 %291, %447
%449 = sext i32 %448 to i64
%450 = getelementptr inbounds double, double* %2, i64 %449
%451 = load double, double* %450
%452 = fmul double %297, %451
%453 = getelementptr inbounds double, double* %4, i64 %449
store double %452, double* %453
%454 = icmp ult i32 %447, 3
br i1 %454, label %455, label %423
455: ; preds = %446
%456 = add i32 %398, 3
%457 = add i32 %291, %456
%458 = sext i32 %457 to i64
%459 = getelementptr inbounds double, double* %2, i64 %458
%460 = load double, double* %459
%461 = fmul double %297, %460
%462 = getelementptr inbounds double, double* %4, i64 %458
store double %461, double* %462
br label %423
463: ; preds = %474
%464 = trunc i64 %489 to i32
br label %465
465: ; preds = %463, %423
%466 = phi i32 [ %32, %423 ], [ %464, %463 ]
%467 = icmp slt i32 %466, %0
br i1 %467, label %468, label %271
468: ; preds = %465
%469 = or i32 %290, 1
%470 = or i32 %290, 2
%471 = or i32 %290, 3
%472 = sext i32 %466 to i64
%473 = sext i32 %290 to i64
br label %491
474: ; preds = %424, %474
%475 = phi i64 [ %35, %424 ], [ %489, %474 ]
%476 = mul nsw i64 %475, %36
%477 = add nsw i64 %476, %428
%478 = getelementptr inbounds double, double* %4, i64 %477
store double 0.000000e+00, double* %478
%479 = trunc i64 %476 to i32
%480 = add i32 %425, %479
%481 = sext i32 %480 to i64
%482 = getelementptr inbounds double, double* %4, i64 %481
store double 0.000000e+00, double* %482
%483 = add i32 %426, %479
%484 = sext i32 %483 to i64
%485 = getelementptr inbounds double, double* %4, i64 %484
store double 0.000000e+00, double* %485
%486 = add i32 %427, %479
%487 = sext i32 %486 to i64
%488 = getelementptr inbounds double, double* %4, i64 %487
store double 0.000000e+00, double* %488
%489 = add nuw nsw i64 %475, 4
%490 = icmp slt i64 %475, %37
br i1 %490, label %474, label %463
491: ; preds = %468, %491
%492 = phi i64 [ %472, %468 ], [ %527, %491 ]
%493 = mul nsw i64 %492, %38
%494 = add nsw i64 %493, %473
%495 = getelementptr inbounds double, double* %2, i64 %494
%496 = load double, double* %495
%497 = fmul double %297, %496
%498 = mul nsw i64 %492, %36
%499 = add nsw i64 %498, %473
%500 = getelementptr inbounds double, double* %4, i64 %499
store double %497, double* %500
%501 = trunc i64 %493 to i32
%502 = add i32 %469, %501
%503 = sext i32 %502 to i64
%504 = getelementptr inbounds double, double* %2, i64 %503
%505 = load double, double* %504
%506 = fmul double %297, %505
%507 = trunc i64 %498 to i32
%508 = add i32 %469, %507
%509 = sext i32 %508 to i64
%510 = getelementptr inbounds double, double* %4, i64 %509
store double %506, double* %510
%511 = add i32 %470, %501
%512 = sext i32 %511 to i64
%513 = getelementptr inbounds double, double* %2, i64 %512
%514 = load double, double* %513
%515 = fmul double %297, %514
%516 = add i32 %470, %507
%517 = sext i32 %516 to i64
%518 = getelementptr inbounds double, double* %4, i64 %517
store double %515, double* %518
%519 = add i32 %471, %501
%520 = sext i32 %519 to i64
%521 = getelementptr inbounds double, double* %2, i64 %520
%522 = load double, double* %521
%523 = fmul double %297, %522
%524 = add i32 %471, %507
%525 = sext i32 %524 to i64
%526 = getelementptr inbounds double, double* %4, i64 %525
store double %523, double* %526
%527 = add nsw i64 %492, 4
%528 = icmp slt i64 %527, %39
br i1 %528, label %491, label %271
529: ; preds = %271, %21
ret void
}