double mod_chol(double *A, int n, double *E, int *P, double *g) {
  int phaseone = 1;
  int i, j, k;
  double tau = pow(2.22044604925031e-16, 1. / 3.);
  double taubar = pow(2.22044604925031e-16, 2.0 / 3.0);
  double mu = 0.1;
  double gamma = 0.0;
  double tmp = 0.;
  double delta = 0.;
  double deltaprev = 0.;
  double normj;
  double lambda_hi;
  double lambda_lo;
  if (n == 1) {
    delta = (taubar * fabs(A[0])) - A[0];
    if (delta > 0.0)
      E[0] = delta;
    else
      E[0] = 0.;
    if (A[0] == 0.0)
      E[0] = taubar;
    A[0] = sqrt(A[0] + E[0]);
    P[0] = 0;
    return E[0];
  }
  for (i = 0; i < n; i++) {
    P[i] = i;
    E[i] = 0.0;
  }
  for (i = 0; i < n; i++) {
    tmp = fabs(A[(((i) * ((i) + 1)) / 2 + (i))]);
    if (tmp > gamma)
      gamma = tmp;
    if (A[(((i) * ((i) + 1)) / 2 + (i))] < 0.0)
      phaseone = 0;
  }
  j = 0;
  while ((j < n) && phaseone) {
    double tmp_max = A[(((j) * ((j) + 1)) / 2 + (j))];
    double tmp_min = A[(((j) * ((j) + 1)) / 2 + (j))];
    int id = j;
    for (i = j + 1; i < n; i++) {
      if (tmp_max < A[(((i) * ((i) + 1)) / 2 + (i))]) {
        tmp_max = A[(((i) * ((i) + 1)) / 2 + (i))];
        id = i;
      }
      if (tmp_min > A[(((i) * ((i) + 1)) / 2 + (i))])
        tmp_min = A[(((i) * ((i) + 1)) / 2 + (i))];
    }
    if (tmp_max < taubar * gamma || tmp_min < -mu * tmp_max) {
      phaseone = 0;
      break;
    } else {
      if (id != j) {
        switch_row_and_colMAT(A, n, id, j);
        switch_row_and_colVEC(P, id, j);
      }
      tmp_min = 0.0;
      for (i = j + 1; i < n; i++) {
        tmp = A[(((i) * ((i) + 1)) / 2 + (i))] -
              A[(((i) * ((i) + 1)) / 2 + (j))] *
                  A[(((i) * ((i) + 1)) / 2 + (j))] /
                  A[(((j) * ((j) + 1)) / 2 + (j))];
        if (tmp_min > tmp)
          tmp_min = tmp;
      }
      if (tmp_min < -mu * gamma) {
        phaseone = 0;
        break;
      } else {
        jthIteration(A, n, j);
        j++;
      }
    }
  }
  if (!phaseone && (j == (n - 1))) {
    delta =
        -A[(((n - 1) * ((n - 1) + 1)) / 2 + (n - 1))] +
        fmax(tau * A[(((n - 1) * ((n - 1) + 1)) / 2 + (n - 1))] / (tau - 1.),
             taubar * gamma);
    A[(((n - 1) * ((n - 1) + 1)) / 2 + (n - 1))] += delta;
    A[(((n - 1) * ((n - 1) + 1)) / 2 + (n - 1))] =
        sqrt(A[(((n - 1) * ((n - 1) + 1)) / 2 + (n - 1))]);
    E[n - 1] = delta;
    deltaprev = delta;
  }
  if (!phaseone && (j < (n - 1))) {
    k = j - 1;
    for (i = k + 1; i < n; i++) {
      g[i] = A[(((i) * ((i) + 1)) / 2 + (i))];
      for (j = k + 1; j <= i - 1; j++) {
        g[i] -= fabs(A[(((i) * ((i) + 1)) / 2 + (j))]);
      }
      for (j = i + 1; j < n; j++) {
        g[i] -= fabs(A[(((j) * ((j) + 1)) / 2 + (i))]);
      }
    }
    for (j = k + 1; j < n - 2; j++) {
      int id = j;
      tmp = g[id];
      for (i = j + 1; i < n; i++) {
        if (tmp < g[i]) {
          tmp = g[i];
          id = i;
        }
      }
      if (id != j) {
        switch_row_and_colMAT(A, n, id, j);
        switch_row_and_colVEC(P, id, j);
        tmp = g[id];
        g[id] = g[j];
        g[j] = tmp;
      }
      normj = 0.;
      for (i = j + 1; i < n; i++) {
        normj += fabs(A[(((i) * ((i) + 1)) / 2 + (j))]);
      }
      delta = fmax(0.0, fmax(fmax(normj, taubar * gamma) -
                                 A[(((j) * ((j) + 1)) / 2 + (j))],
                             deltaprev));
      if (delta > 0) {
        A[(((j) * ((j) + 1)) / 2 + (j))] += delta;
        deltaprev = delta;
        E[j] = delta;
      }
      if (A[(((j) * ((j) + 1)) / 2 + (j))] != normj) {
        tmp = 1.0 - normj / A[(((j) * ((j) + 1)) / 2 + (j))];
        for (i = j + 1; i < n; i++) {
          g[i] += fabs(A[(((i) * ((i) + 1)) / 2 + (j))]) * tmp;
        }
      }
      jthIteration(A, n, j);
    }
    tmp = sqrt((A[(((n - 2) * ((n - 2) + 1)) / 2 + (n - 2))] -
                A[(((n - 1) * ((n - 1) + 1)) / 2 + (n - 1))]) *
                   (A[(((n - 2) * ((n - 2) + 1)) / 2 + (n - 2))] -
                    A[(((n - 1) * ((n - 1) + 1)) / 2 + (n - 1))]) +
               4.0 * A[(((n - 2) * ((n - 2) + 1)) / 2 + (n - 1))] *
                   A[(((n - 2) * ((n - 2) + 1)) / 2 + (n - 1))]);
    lambda_hi = ((A[(((n - 2) * ((n - 2) + 1)) / 2 + (n - 2))] +
                  A[(((n - 1) * ((n - 1) + 1)) / 2 + (n - 1))]) +
                 tmp) *
                0.5;
    lambda_lo = ((A[(((n - 2) * ((n - 2) + 1)) / 2 + (n - 2))] +
                  A[(((n - 1) * ((n - 1) + 1)) / 2 + (n - 1))]) -
                 tmp) *
                0.5;
    delta = fmax(
        fmax(0.0, -lambda_lo + fmax(tau * (lambda_hi - lambda_lo) / (1.0 - tau),
                                    taubar * gamma)),
        deltaprev);
    if (delta > 0) {
      A[(((n - 2) * ((n - 2) + 1)) / 2 + (n - 2))] += delta;
      A[(((n - 1) * ((n - 1) + 1)) / 2 + (n - 1))] += delta;
      deltaprev = delta;
      E[n - 2] = delta;
      E[n - 1] = delta;
    }
    A[(((n - 2) * ((n - 2) + 1)) / 2 + (n - 2))] =
        sqrt(A[(((n - 2) * ((n - 2) + 1)) / 2 + (n - 2))]);
    A[(((n - 2) * ((n - 2) + 1)) / 2 + (n - 1))] /=
        A[(((n - 2) * ((n - 2) + 1)) / 2 + (n - 2))];
    A[(((n - 1) * ((n - 1) + 1)) / 2 + (n - 1))] =
        sqrt(A[(((n - 1) * ((n - 1) + 1)) / 2 + (n - 1))] -
             A[(((n - 2) * ((n - 2) + 1)) / 2 + (n - 1))] *
                 A[(((n - 2) * ((n - 2) + 1)) / 2 + (n - 1))]);
  }
  return deltaprev;
}


x86 assembly (clang, -O0):
<mod_chol>:
push   %rbp
mov    %rsp,%rbp
sub    $0x220,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
movl   $0x1,-0x34(%rbp)
movsd  0x1e8b(%rip),%xmm0
movsd  0x1e93(%rip),%xmm1
call   1050 <pow@plt>
movsd  %xmm0,-0x48(%rbp)
movsd  0x1e71(%rip),%xmm0
movsd  0x1e71(%rip),%xmm1
call   1050 <pow@plt>
movsd  %xmm0,-0x50(%rbp)
movsd  0x1e4f(%rip),%xmm0
movsd  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
cmpl   $0x1,-0x14(%rbp)
jne    12b4 <mod_chol+0x164>
movsd  -0x50(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
movaps 0x1e4c(%rip),%xmm1
pand   %xmm1,%xmm2
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1248 <mod_chol+0xf8>
movsd  -0x70(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,(%rax)
jmp    1253 <mod_chol+0x103>
mov    -0x20(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    127b <mod_chol+0x12b>
jp     127b <mod_chol+0x12b>
movsd  -0x50(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x20(%rbp),%rax
addsd  (%rax),%xmm0
call   1070 <sqrt@plt>
mov    -0x10(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x28(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    253f <mod_chol+0x13ef>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12f3 <mod_chol+0x1a3>
mov    -0x38(%rbp),%edx
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    12bb <mod_chol+0x16b>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    13b9 <mod_chol+0x269>
mov    -0x10(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0xb0(%rbp),%rax
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x1d00(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm0
ucomisd -0x60(%rbp),%xmm0
jbe    1363 <mod_chol+0x213>
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0xb8(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0xb8(%rbp),%rax
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jbe    13a6 <mod_chol+0x256>
movl   $0x0,-0x34(%rbp)
jmp    13ab <mod_chol+0x25b>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    12fa <mod_chol+0x1aa>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%ecx
xor    %eax,%eax
cmp    -0x14(%rbp),%ecx
mov    %al,-0xb9(%rbp)
jge    13e1 <mod_chol+0x291>
cmpl   $0x0,-0x34(%rbp)
setne  %al
mov    %al,-0xb9(%rbp)
mov    -0xb9(%rbp),%al
test   $0x1,%al
jne    13f4 <mod_chol+0x2a4>
jmp    17c3 <mod_chol+0x673>
mov    -0x10(%rbp),%rax
mov    %rax,-0xd0(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0xd0(%rbp),%rax
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    %rax,-0xc8(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0xc8(%rbp),%rax
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x3c(%rbp),%eax
mov    %eax,-0xa4(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    15a0 <mod_chol+0x450>
movsd  -0x98(%rbp),%xmm1
ff
mov    -0x10(%rbp),%rax
mov    %rax,-0xd8(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0xd8(%rbp),%rax
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    1511 <mod_chol+0x3c1>
mov    -0x10(%rbp),%rax
mov    %rax,-0xe0(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0xe0(%rbp),%rax
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x38(%rbp),%eax
mov    %eax,-0xa4(%rbp)
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    %rax,-0xe8(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0xe8(%rbp),%rax
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    158d <mod_chol+0x43d>
mov    -0x10(%rbp),%rax
mov    %rax,-0xf0(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0xf0(%rbp),%rax
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
jmp    1592 <mod_chol+0x442>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    147c <mod_chol+0x32c>
movsd  -0x98(%rbp),%xmm1
ff
movsd  -0x50(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
ucomisd %xmm1,%xmm0
ja     15f2 <mod_chol+0x4a2>
movsd  -0xa0(%rbp),%xmm1
ff
movsd  -0x58(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x98(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    15fe <mod_chol+0x4ae>
movl   $0x0,-0x34(%rbp)
jmp    17c3 <mod_chol+0x673>
mov    -0xa4(%rbp),%eax
cmp    -0x3c(%rbp),%eax
je     1638 <mod_chol+0x4e8>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0xa4(%rbp),%edx
mov    -0x3c(%rbp),%ecx
mov    $0x0,%al
call   1030 <switch_row_and_colMAT@plt>
mov    -0x28(%rbp),%rdi
mov    -0xa4(%rbp),%esi
mov    -0x3c(%rbp),%edx
mov    $0x0,%al
call   1040 <switch_row_and_colVEC@plt>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1760 <mod_chol+0x610>
mov    -0x10(%rbp),%rax
mov    %rax,-0x110(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x110(%rbp),%rax
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    %rax,-0x108(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x108(%rbp),%rax
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
mov    %rax,-0x100(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x100(%rbp),%rax
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
mov    %rax,-0xf8(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0xf8(%rbp),%rax
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0xa0(%rbp),%xmm0
ff
ucomisd -0x68(%rbp),%xmm0
jbe    174d <mod_chol+0x5fd>
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
jmp    1752 <mod_chol+0x602>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    164c <mod_chol+0x4fc>
movsd  -0xa0(%rbp),%xmm1
ff
movsd  -0x58(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x60(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    179f <mod_chol+0x64f>
movl   $0x0,-0x34(%rbp)
jmp    17c3 <mod_chol+0x673>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x3c(%rbp),%edx
mov    $0x0,%al
call   1060 <jthIteration@plt>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    17be <mod_chol+0x66e>
jmp    13c0 <mod_chol+0x270>
cmpl   $0x0,-0x34(%rbp)
jne    19a6 <mod_chol+0x856>
mov    -0x3c(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    19a6 <mod_chol+0x856>
mov    -0x10(%rbp),%rax
mov    %rax,-0x138(%rbp)
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x138(%rbp),%rax
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x48(%rbp),%xmm4
mov    -0x10(%rbp),%rax
mov    %rax,-0x130(%rbp)
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x130(%rbp),%rax
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm4
movsd  -0x48(%rbp),%xmm1
movsd  0x179d(%rip),%xmm2
subsd  %xmm2,%xmm1
divsd  %xmm1,%xmm4
movsd  -0x50(%rbp),%xmm3
mulsd  -0x60(%rbp),%xmm3
movaps %xmm3,%xmm5
movaps %xmm4,%xmm1
cmpunordsd %xmm1,%xmm1
movaps %xmm1,%xmm2
pand   %xmm5,%xmm2
maxsd  %xmm4,%xmm3
pandn  %xmm3,%xmm1
por    %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    %rax,-0x128(%rbp)
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x128(%rbp),%rax
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
mov    %rax,-0x120(%rbp)
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x120(%rbp),%rax
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1070 <sqrt@plt>
mov    -0x10(%rbp),%rax
mov    %rax,-0x118(%rbp)
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x118(%rbp),%rax
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
cmpl   $0x0,-0x34(%rbp)
jne    2535 <mod_chol+0x13e5>
mov    -0x3c(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    2535 <mod_chol+0x13e5>
mov    -0x3c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1b25 <mod_chol+0x9d5>
mov    -0x10(%rbp),%rax
mov    %rax,-0x140(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x140(%rbp),%rax
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1a9b <mod_chol+0x94b>
mov    -0x10(%rbp),%rax
mov    %rax,-0x148(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x148(%rbp),%rax
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x15cd(%rip),%xmm0
pand   %xmm0,%xmm1
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1a28 <mod_chol+0x8d8>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1b12 <mod_chol+0x9c2>
mov    -0x10(%rbp),%rax
mov    %rax,-0x150(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x150(%rbp),%rax
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x1556(%rip),%xmm0
pand   %xmm0,%xmm1
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1aa4 <mod_chol+0x954>
jmp    1b17 <mod_chol+0x9c7>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    19d3 <mod_chol+0x883>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jge    1edd <mod_chol+0xd8d>
mov    -0x3c(%rbp),%eax
mov    %eax,-0xa8(%rbp)
mov    -0x30(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1bbc <mod_chol+0xa6c>
movsd  -0x68(%rbp),%xmm1
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    1ba9 <mod_chol+0xa59>
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0xa8(%rbp)
jmp    1bae <mod_chol+0xa5e>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1b66 <mod_chol+0xa16>
mov    -0xa8(%rbp),%eax
cmp    -0x3c(%rbp),%eax
je     1c3a <mod_chol+0xaea>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0xa8(%rbp),%edx
mov    -0x3c(%rbp),%ecx
mov    $0x0,%al
call   1030 <switch_row_and_colMAT@plt>
mov    -0x28(%rbp),%rdi
mov    -0xa8(%rbp),%esi
mov    -0x3c(%rbp),%edx
mov    $0x0,%al
call   1040 <switch_row_and_colVEC@plt>
mov    -0x30(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1cad <mod_chol+0xb5d>
mov    -0x10(%rbp),%rax
mov    %rax,-0x158(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x158(%rbp),%rax
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x13af(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1c4b <mod_chol+0xafb>
movsd  -0x80(%rbp),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  -0x60(%rbp),%xmm1
movaps %xmm1,%xmm4
movaps %xmm2,%xmm3
cmpunordsd %xmm3,%xmm3
movaps %xmm3,%xmm0
pand   %xmm4,%xmm0
maxsd  %xmm2,%xmm1
pandn  %xmm1,%xmm3
por    %xmm0,%xmm3
mov    -0x10(%rbp),%rax
mov    %rax,-0x160(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x160(%rbp),%rax
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm3
movsd  -0x78(%rbp),%xmm2
movaps %xmm2,%xmm4
movaps %xmm3,%xmm0
cmpunordsd %xmm0,%xmm0
movaps %xmm0,%xmm1
pand   %xmm4,%xmm1
maxsd  %xmm3,%xmm2
pandn  %xmm2,%xmm0
por    %xmm1,%xmm0
xorps  %xmm1,%xmm1
maxsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1da7 <mod_chol+0xc57>
movsd  -0x70(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    %rax,-0x168(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x168(%rbp),%rax
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x70(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
mov    %rax,-0x170(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x170(%rbp),%rax
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0x80(%rbp),%xmm0
jne    1df0 <mod_chol+0xca0>
jp     1df0 <mod_chol+0xca0>
jmp    1ebe <mod_chol+0xd6e>
movsd  -0x80(%rbp),%xmm1
mov    -0x10(%rbp),%rax
mov    %rax,-0x178(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x178(%rbp),%rax
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm1
movsd  0x11f0(%rip),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1eb9 <mod_chol+0xd69>
mov    -0x10(%rbp),%rax
mov    %rax,-0x180(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x180(%rbp),%rax
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x11b8(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  -0x68(%rbp),%xmm2
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1e42 <mod_chol+0xcf2>
jmp    1ebe <mod_chol+0xd6e>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x3c(%rbp),%edx
mov    $0x0,%al
call   1060 <jthIteration@plt>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1b2e <mod_chol+0x9de>
mov    -0x10(%rbp),%rax
mov    %rax,-0x1d0(%rbp)
mov    -0x14(%rbp),%eax
sub    $0x2,%eax
mov    -0x14(%rbp),%ecx
sub    $0x2,%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x1d0(%rbp),%rax
mov    -0x14(%rbp),%edx
sub    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    %rax,-0x1c8(%rbp)
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x1c8(%rbp),%rax
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    %rax,-0x1c0(%rbp)
mov    -0x14(%rbp),%eax
sub    $0x2,%eax
mov    -0x14(%rbp),%ecx
sub    $0x2,%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x1c0(%rbp),%rax
mov    -0x14(%rbp),%edx
sub    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
mov    %rax,-0x1b8(%rbp)
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x1b8(%rbp),%rax
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
mov    %rax,-0x1b0(%rbp)
mov    -0x14(%rbp),%eax
sub    $0x2,%eax
mov    -0x14(%rbp),%ecx
sub    $0x2,%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x1b0(%rbp),%rax
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  0x101a(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
mov    %rax,-0x1a8(%rbp)
mov    -0x14(%rbp),%eax
sub    $0x2,%eax
mov    -0x14(%rbp),%ecx
sub    $0x2,%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x1a8(%rbp),%rax
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1070 <sqrt@plt>
movsd  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x1a0(%rbp)
mov    -0x14(%rbp),%eax
sub    $0x2,%eax
mov    -0x14(%rbp),%ecx
sub    $0x2,%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x1a0(%rbp),%rax
mov    -0x14(%rbp),%edx
sub    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    %rax,-0x198(%rbp)
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x198(%rbp),%rax
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
addsd  -0x68(%rbp),%xmm0
movsd  0xf34(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    %rax,-0x190(%rbp)
mov    -0x14(%rbp),%eax
sub    $0x2,%eax
mov    -0x14(%rbp),%ecx
sub    $0x2,%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x190(%rbp),%rax
mov    -0x14(%rbp),%edx
sub    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    %rax,-0x188(%rbp)
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x188(%rbp),%rax
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
subsd  -0x68(%rbp),%xmm0
movsd  0xe9f(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
movsd  -0x48(%rbp),%xmm4
movsd  -0x88(%rbp),%xmm0
ff
subsd  -0x90(%rbp),%xmm0
ff
mulsd  %xmm0,%xmm4
movsd  0xe4b(%rip),%xmm0
subsd  -0x48(%rbp),%xmm0
divsd  %xmm0,%xmm4
movsd  -0x50(%rbp),%xmm2
mulsd  -0x60(%rbp),%xmm2
movaps %xmm2,%xmm5
movaps %xmm4,%xmm0
cmpunordsd %xmm0,%xmm0
movaps %xmm0,%xmm1
pand   %xmm5,%xmm1
maxsd  %xmm4,%xmm2
pandn  %xmm2,%xmm0
por    %xmm1,%xmm0
addsd  %xmm0,%xmm3
xorps  %xmm0,%xmm0
maxsd  %xmm0,%xmm3
movsd  -0x78(%rbp),%xmm2
movaps %xmm2,%xmm4
movaps %xmm3,%xmm0
cmpunordsd %xmm0,%xmm0
movaps %xmm0,%xmm1
pand   %xmm4,%xmm1
maxsd  %xmm3,%xmm2
pandn  %xmm2,%xmm0
por    %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    2313 <mod_chol+0x11c3>
movsd  -0x70(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    %rax,-0x1e0(%rbp)
mov    -0x14(%rbp),%eax
sub    $0x2,%eax
mov    -0x14(%rbp),%ecx
sub    $0x2,%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x1e0(%rbp),%rax
mov    -0x14(%rbp),%edx
sub    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    %rax,-0x1d8(%rbp)
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x1d8(%rbp),%rax
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x70(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
mov    %rax,-0x220(%rbp)
mov    -0x14(%rbp),%eax
sub    $0x2,%eax
mov    -0x14(%rbp),%ecx
sub    $0x2,%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x220(%rbp),%rax
mov    -0x14(%rbp),%edx
sub    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1070 <sqrt@plt>
mov    -0x10(%rbp),%rax
mov    %rax,-0x218(%rbp)
mov    -0x14(%rbp),%eax
sub    $0x2,%eax
mov    -0x14(%rbp),%ecx
sub    $0x2,%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x218(%rbp),%rax
mov    -0x14(%rbp),%edx
sub    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
mov    %rax,-0x210(%rbp)
mov    -0x14(%rbp),%eax
sub    $0x2,%eax
mov    -0x14(%rbp),%ecx
sub    $0x2,%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x210(%rbp),%rax
mov    -0x14(%rbp),%edx
sub    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
mov    %rax,-0x208(%rbp)
mov    -0x14(%rbp),%eax
sub    $0x2,%eax
mov    -0x14(%rbp),%ecx
sub    $0x2,%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x208(%rbp),%rax
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
mov    %rax,-0x200(%rbp)
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x200(%rbp),%rax
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
mov    %rax,-0x1f8(%rbp)
mov    -0x14(%rbp),%eax
sub    $0x2,%eax
mov    -0x14(%rbp),%ecx
sub    $0x2,%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x1f8(%rbp),%rax
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    %rax,-0x1f0(%rbp)
mov    -0x14(%rbp),%eax
sub    $0x2,%eax
mov    -0x14(%rbp),%ecx
sub    $0x2,%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x1f0(%rbp),%rax
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1070 <sqrt@plt>
mov    -0x10(%rbp),%rax
mov    %rax,-0x1e8(%rbp)
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x1e8(%rbp),%rax
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x8(%rbp)
movsd  -0x8(%rbp),%xmm0
add    $0x220,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<mod_chol>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
mov    %r8,0x38(%rsp)
mov    %rcx,%r13
mov    %rdx,%r15
mov    %rdi,%r14
cmp    $0x1,%esi
jne    11c2 <mod_chol+0x82>
movsd  (%r14),%xmm1
movapd 0xee2(%rip),%xmm0
andpd  %xmm1,%xmm0
mulsd  0xee6(%rip),%xmm0
subsd  %xmm1,%xmm0
xorpd  %xmm1,%xmm1
maxsd  %xmm1,%xmm0
movsd  %xmm0,(%r15)
movsd  (%r14),%xmm2
ucomisd %xmm1,%xmm2
jne    11b2 <mod_chol+0x72>
jp     11b2 <mod_chol+0x72>
movabs $0x3dc428a2f98d728d,%rax
28 c4 3d
mov    %rax,(%r15)
movsd  (%r14),%xmm2
movsd  0xeae(%rip),%xmm0
addsd  %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jb     11d9 <mod_chol+0x99>
sqrtsd %xmm0,%xmm0
jmp    11de <mod_chol+0x9e>
xorps  %xmm8,%xmm8
jl     11f0 <mod_chol+0xb0>
mov    %esi,%r12d
mov    %esi,%eax
cmp    $0x4,%esi
jae    1203 <mod_chol+0xc3>
xor    %ecx,%ecx
jmp    12f0 <mod_chol+0x1b0>
call   1060 <sqrt@plt>
movsd  %xmm0,(%r14)
movl   $0x0,0x0(%r13)
movsd  (%r15),%xmm8
movaps %xmm8,%xmm0
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %eax,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rsi
mov    %rsi,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rsi,%rsi
je     1763 <mod_chol+0x623>
mov    %rdx,%rdi
and    $0xfffffffffffffffe,%rdi
movdqa 0xdd1(%rip),%xmm0
xor    %esi,%esi
movdqa 0xdd7(%rip),%xmm1
xorpd  %xmm2,%xmm2
movdqa 0xddb(%rip),%xmm3
movdqa 0xde3(%rip),%xmm4
movdqa 0xdeb(%rip),%xmm5
cs nopw 0x0(%rax,%rax,1)
nop
movdqa %xmm0,%xmm6
paddd  %xmm1,%xmm6
movdqa %xmm0,%xmm7
punpcklqdq %xmm6,%xmm7
movdqu %xmm7,0x0(%r13,%rsi,4)
movupd %xmm2,(%r15,%rsi,8)
movupd %xmm2,0x10(%r15,%rsi,8)
movdqa %xmm0,%xmm6
paddd  %xmm3,%xmm6
movdqa %xmm0,%xmm7
paddd  %xmm4,%xmm7
punpcklqdq %xmm7,%xmm6
movdqu %xmm6,0x10(%r13,%rsi,4)
movupd %xmm2,0x20(%r15,%rsi,8)
movupd %xmm2,0x30(%r15,%rsi,8)
add    $0x8,%rsi
paddd  %xmm5,%xmm0
add    $0xfffffffffffffffe,%rdi
jne    1260 <mod_chol+0x120>
test   $0x1,%dl
je     12e8 <mod_chol+0x1a8>
movdqa 0xd48(%rip),%xmm1
paddd  %xmm0,%xmm1
punpcklqdq %xmm1,%xmm0
movdqu %xmm0,0x0(%r13,%rsi,4)
pxor   %xmm0,%xmm0
movdqu %xmm0,(%r15,%rsi,8)
movdqu %xmm0,0x10(%r15,%rsi,8)
cmp    %rax,%rcx
je     1306 <mod_chol+0x1c6>
nopl   (%rax)
mov    %ecx,0x0(%r13,%rcx,4)
movq   $0x0,(%r15,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    12f0 <mod_chol+0x1b0>
test   %r12d,%r12d
jle    11f0 <mod_chol+0xb0>
mov    %r12d,%eax
add    $0xffffffff,%eax
mov    %eax,0xc(%rsp)
je     1748 <mod_chol+0x608>
mov    %r12d,%r8d
and    $0xfffffffe,%r8d
pxor   %xmm0,%xmm0
mov    $0x1,%eax
mov    $0x1,%r11d
mov    $0xa,%edi
mov    $0x2,%ebp
mov    $0x6,%ebx
xor    %r9d,%r9d
movapd 0xd01(%rip),%xmm1
xor    %edx,%edx
xor    %r10d,%r10d
pxor   %xmm4,%xmm4
nopl   0x0(%rax,%rax,1)
mov    %ebp,%ecx
shr    %rcx
add    %r11,%rcx
mov    %edx,%esi
shr    %rsi
add    %r10,%rsi
movsd  (%r14,%rsi,8),%xmm2
add    $0x2,%r10
ucomisd %xmm2,%xmm0
cmova  %r9d,%eax
andpd  %xmm1,%xmm2
movsd  (%r14,%rcx,8),%xmm3
ucomisd %xmm3,%xmm0
maxsd  %xmm4,%xmm2
movapd %xmm3,%xmm4
cmova  %r9d,%eax
andpd  %xmm1,%xmm4
maxsd  %xmm2,%xmm4
add    $0x2,%r11
add    %edi,%ebp
add    $0x8,%edi
add    %ebx,%edx
add    $0x8,%ebx
cmp    %r10d,%r8d
jne    1360 <mod_chol+0x220>
test   $0x1,%r12b
je     13f1 <mod_chol+0x2b1>
lea    0x1(%r10),%edx
imul   %r10d,%edx
shr    %edx
add    %r10d,%edx
movsd  (%r14,%rdx,8),%xmm0
xor    %ecx,%ecx
xorpd  %xmm1,%xmm1
ucomisd %xmm0,%xmm1
movapd 0xc6e(%rip),%xmm1
andpd  %xmm0,%xmm1
maxsd  %xmm4,%xmm1
cmova  %ecx,%eax
movapd %xmm1,%xmm4
test   %r12d,%r12d
movaps %xmm4,0x20(%rsp)
jle    16a9 <mod_chol+0x569>
test   %eax,%eax
je     16a9 <mod_chol+0x569>
mov    %r13,0x58(%rsp)
mov    %r15,0x30(%rsp)
movsd  0xc47(%rip),%xmm0
mulsd  %xmm4,%xmm0
movsd  %xmm0,0x70(%rsp)
movsd  0xc3d(%rip),%xmm0
mulsd  %xmm4,%xmm0
movsd  %xmm0,0x68(%rsp)
lea    -0x2(%r12),%eax
mov    %eax,0x64(%rsp)
mov    $0x1,%r15d
mov    $0x4,%ebx
movl   $0x2,0x1c(%rsp)
xor    %r13d,%r13d
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    0x1(%r13),%r10d
mov    %r10d,%r11d
imul   %r13d,%r11d
shr    %r11d
add    %r13d,%r11d
movsd  (%r14,%r11,8),%xmm2
cmp    %r12d,%r10d
mov    %r15,0x40(%rsp)
mov    %ebx,0x10(%rsp)
jge    14b0 <mod_chol+0x370>
mov    0xc(%rsp),%eax
sub    %r13d,%eax
test   $0x1,%al
jne    14c0 <mod_chol+0x380>
mov    %r13d,%r15d
movapd %xmm2,%xmm0
mov    %r10d,%ebx
cmp    %r13d,0x64(%rsp)
jne    14fb <mod_chol+0x3bb>
jmp    1590 <mod_chol+0x450>
cs nopw 0x0(%rax,%rax,1)
movapd %xmm2,%xmm0
movapd %xmm2,%xmm1
mov    %r13d,%r15d
jmp    1590 <mod_chol+0x450>
lea    0x2(%r13),%ebx
mov    %ebx,%eax
imul   %r10d,%eax
shr    %eax
add    %r10d,%eax
movsd  (%r14,%rax,8),%xmm1
ucomisd %xmm2,%xmm1
movapd %xmm1,%xmm0
maxsd  %xmm2,%xmm0
mov    %r13d,%r15d
cmova  %r10d,%r15d
minsd  %xmm2,%xmm1
movapd %xmm1,%xmm2
cmp    %r13d,0x64(%rsp)
je     1590 <mod_chol+0x450>
mov    %ebx,%eax
lea    0x1(%rbx),%r8d
mov    %ebx,%r9d
imul   %r8d,%r9d
lea    0x6(,%rbx,4),%edx
lea    0x1(%rax),%rsi
mov    %ebx,%edi
add    $0x2,%edi
imul   %r8d,%edi
lea    0xa(,%rbx,4),%ebx
movapd %xmm2,%xmm1
nopw   0x0(%rax,%rax,1)
mov    %r9d,%ebp
shr    %rbp
add    %rax,%rbp
mov    %edi,%ecx
shr    %rcx
add    %rsi,%rcx
movsd  (%r14,%rbp,8),%xmm2
ucomisd %xmm0,%xmm2
movapd %xmm2,%xmm3
maxsd  %xmm0,%xmm3
cmova  %eax,%r15d
minsd  %xmm1,%xmm2
movsd  (%r14,%rcx,8),%xmm1
lea    0x1(%rax),%ecx
ucomisd %xmm3,%xmm1
movapd %xmm1,%xmm0
maxsd  %xmm3,%xmm0
cmova  %ecx,%r15d
minsd  %xmm2,%xmm1
add    $0x2,%rax
add    %edx,%r9d
add    $0x8,%edx
add    $0x2,%rsi
add    %ebx,%edi
add    $0x8,%ebx
cmp    %r12d,%eax
jne    1530 <mod_chol+0x3f0>
movsd  0x70(%rsp),%xmm2
ucomisd %xmm0,%xmm2
mulsd  0xac6(%rip),%xmm0
ja     16c2 <mod_chol+0x582>
ucomisd %xmm1,%xmm0
ja     16c2 <mod_chol+0x582>
cmp    %r13d,%r15d
je     15ee <mod_chol+0x4ae>
mov    %r14,%rdi
mov    %r12d,%esi
mov    %r15d,%edx
mov    %r13d,%ecx
xor    %eax,%eax
mov    %r10d,%ebx
mov    %r11,%rbp
call   1030 <switch_row_and_colMAT@plt>
mov    0x58(%rsp),%rdi
mov    %r15d,%esi
mov    %r13d,%edx
xor    %eax,%eax
call   1040 <switch_row_and_colVEC@plt>
mov    %rbp,%r11
mov    %ebx,%r10d
movapd 0x20(%rsp),%xmm4
xorpd  %xmm2,%xmm2
cmp    %r12d,%r10d
mov    0x40(%rsp),%r15
mov    0x10(%rsp),%ebx
jge    1664 <mod_chol+0x524>
movsd  (%r14,%r11,8),%xmm0
xorpd  %xmm1,%xmm1
mov    0x1c(%rsp),%eax
mov    %ebx,%ecx
mov    %r15,%rsi
mov    %r15,%rdx
cs nopw 0x0(%rax,%rax,1)
mov    %eax,%edi
shr    %rdi
lea    0x1(%rsi),%ebp
imul   %esi,%ebp
add    %rsi,%rdi
shr    %ebp
add    %r13d,%ebp
movsd  (%r14,%rbp,8),%xmm3
movsd  (%r14,%rdi,8),%xmm2
mulsd  %xmm3,%xmm3
divsd  %xmm0,%xmm3
subsd  %xmm3,%xmm2
add    $0x1,%rdx
minsd  %xmm1,%xmm2
add    %ecx,%eax
add    $0x2,%ecx
mov    %rdx,%rsi
movapd %xmm2,%xmm1
cmp    %edx,%r12d
jne    1620 <mod_chol+0x4e0>
movsd  0x68(%rsp),%xmm0
ucomisd %xmm2,%xmm0
ja     16c2 <mod_chol+0x582>
mov    %r14,%rdi
mov    %r12d,%esi
mov    %r13d,%edx
xor    %eax,%eax
mov    %r10d,%ebp
call   1050 <jthIteration@plt>
movapd 0x20(%rsp),%xmm4
add    $0x1,%r15
add    %ebx,0x1c(%rsp)
add    $0x2,%ebx
mov    %ebp,%r13d
cmp    %r12d,%ebp
jne    1460 <mod_chol+0x320>
xorps  %xmm8,%xmm8
jmp    11f0 <mod_chol+0xb0>
xorps  %xmm8,%xmm8
test   %eax,%eax
jne    11f0 <mod_chol+0xb0>
mov    %r13,0x58(%rsp)
mov    %r15,0x30(%rsp)
xor    %r13d,%r13d
xorps  %xmm8,%xmm8
cmp    0xc(%rsp),%r13d
jne    17a0 <mod_chol+0x660>
mov    %r13d,%eax
imul   %r12d,%eax
mov    %eax,%ecx
shr    $0x1f,%ecx
add    %eax,%ecx
sar    %ecx
add    %r13d,%ecx
movslq %ecx,%rbx
movsd  (%r14,%rbx,8),%xmm0
movsd  0x97b(%rip),%xmm5
mulsd  %xmm0,%xmm5
divsd  0x977(%rip),%xmm5
movsd  0x957(%rip),%xmm1
mulsd  %xmm4,%xmm1
movapd %xmm1,%xmm2
maxsd  %xmm5,%xmm2
cmpunordsd %xmm5,%xmm5
movapd %xmm5,%xmm3
andnpd %xmm2,%xmm3
andpd  %xmm1,%xmm5
orpd   %xmm3,%xmm5
subsd  %xmm0,%xmm5
movapd %xmm5,0x40(%rsp)
addsd  %xmm5,%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     177b <mod_chol+0x63b>
sqrtsd %xmm0,%xmm0
jmp    1786 <mod_chol+0x646>
xor    %r10d,%r10d
pxor   %xmm4,%xmm4
mov    $0x1,%eax
test   $0x1,%r12b
jne    13bd <mod_chol+0x27d>
jmp    13f1 <mod_chol+0x2b1>
movdqa 0x895(%rip),%xmm0
xor    %esi,%esi
test   $0x1,%dl
jne    12c0 <mod_chol+0x180>
jmp    12e8 <mod_chol+0x1a8>
call   1060 <sqrt@plt>
movapd 0x20(%rsp),%xmm4
movsd  %xmm0,(%r14,%rbx,8)
mov    %r13d,%eax
mov    0x30(%rsp),%rcx
movaps 0x40(%rsp),%xmm8
movsd  %xmm8,(%rcx,%rax,8)
cmp    0xc(%rsp),%r13d
jge    11f0 <mod_chol+0xb0>
movaps %xmm8,0x40(%rsp)
cmp    %r12d,%r13d
mov    0x38(%rsp),%rbp
jge    18cd <mod_chol+0x78d>
mov    %r13d,%r10d
lea    0x1(%r10),%r9
lea    0x8(%r14),%r8
mov    %r9,%r11
imul   %r10,%r11
lea    (%r10,%r10,1),%rdi
add    $0x2,%rdi
xor    %ebx,%ebx
movapd 0x86d(%rip),%xmm0
movapd 0x865(%rip),%xmm1
mov    %r10,%rdx
xchg   %ax,%ax
lea    0x1(%rdx),%rcx
mov    %edx,%eax
imul   %ecx,%eax
shr    %eax
lea    (%rax,%rdx,1),%rsi
movsd  (%r14,%rsi,8),%xmm2
movsd  %xmm2,0x0(%rbp,%rdx,8)
cmp    %r10,%rdx
jbe    1880 <mod_chol+0x740>
test   $0x1,%bl
jne    181a <mod_chol+0x6da>
mov    %r10,%rax
jmp    1834 <mod_chol+0x6f4>
add    %r10,%rax
movsd  (%r14,%rax,8),%xmm3
andpd  %xmm1,%xmm3
subsd  %xmm3,%xmm2
movsd  %xmm2,0x0(%rbp,%rdx,8)
mov    %r9,%rax
cmp    $0x1,%rbx
mov    0x38(%rsp),%rbp
je     1880 <mod_chol+0x740>
mov    %r11d,%esi
and    $0xfffffffe,%esi
lea    (%r8,%rsi,4),%rsi
nopl   0x0(%rax)
movsd  -0x8(%rsi,%rax,8),%xmm3
andpd  %xmm0,%xmm3
subsd  %xmm3,%xmm2
movsd  %xmm2,0x0(%rbp,%rdx,8)
movsd  (%rsi,%rax,8),%xmm3
andpd  %xmm0,%xmm3
subsd  %xmm3,%xmm2
movsd  %xmm2,0x0(%rbp,%rdx,8)
add    $0x2,%rax
cmp    %rax,%rdx
jne    1850 <mod_chol+0x710>
mov    %ecx,%eax
cmp    %r12d,%ecx
jge    18cd <mod_chol+0x78d>
nopw   0x0(%rax,%rax,1)
lea    0x1(%rax),%esi
imul   %esi,%eax
shr    %eax
add    %rdx,%rax
movsd  (%r14,%rax,8),%xmm3
andpd  %xmm1,%xmm3
subsd  %xmm3,%xmm2
movsd  %xmm2,0x0(%rbp,%rdx,8)
mov    %esi,%eax
cmp    %r12d,%esi
jl     1890 <mod_chol+0x750>
add    $0x1,%rbx
add    %rdi,%r11
add    $0x2,%rdi
mov    %rcx,%rdx
cmp    %r12d,%ecx
jl     17f0 <mod_chol+0x6b0>
lea    -0x2(%r12),%eax
mulsd  0x786(%rip),%xmm4
movapd %xmm4,0x20(%rsp)
mov    %rax,0x10(%rsp)
cmp    %eax,%r13d
jge    1ae6 <mod_chol+0x9a6>
mov    %r13d,%r13d
movapd 0x757(%rip),%xmm6
jmp    1922 <mod_chol+0x7e2>
nopl   0x0(%rax,%rax,1)
mov    %r14,%rdi
mov    %r12d,%esi
mov    %ebp,%edx
xor    %eax,%eax
call   1050 <jthIteration@plt>
movapd 0x739(%rip),%xmm6
cmp    %r13d,0x10(%rsp)
jle    1ae6 <mod_chol+0x9a6>
mov    %r13,%rbp
lea    0x1(%r13),%rax
mov    %eax,%r15d
mov    %ebp,%ebx
mov    %rax,%r13
cmp    %r12d,%eax
mov    0x38(%rsp),%rdx
jge    196d <mod_chol+0x82d>
movsd  (%rdx,%rbp,8),%xmm0
mov    %r15,%rax
mov    %ebp,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rdx,%rax,8),%xmm1
ucomisd %xmm0,%xmm1
cmova  %eax,%ebx
maxsd  %xmm0,%xmm1
add    $0x1,%rax
movapd %xmm1,%xmm0
cmp    %r12d,%eax
jl     1950 <mod_chol+0x810>
mov    %ebx,%eax
cmp    %rax,%rbp
movapd 0x20(%rsp),%xmm3
je     19c5 <mod_chol+0x885>
mov    %r14,%rdi
mov    %r12d,%esi
mov    %ebx,%edx
mov    %ebp,%ecx
xor    %eax,%eax
call   1030 <switch_row_and_colMAT@plt>
mov    0x58(%rsp),%rdi
mov    %ebx,%esi
mov    %ebp,%edx
xor    %eax,%eax
call   1040 <switch_row_and_colVEC@plt>
movapd 0x6ad(%rip),%xmm6
movapd 0x20(%rsp),%xmm3
mov    0x38(%rsp),%rdx
movslq %ebx,%rax
movsd  (%rdx,%rax,8),%xmm0
movsd  (%rdx,%rbp,8),%xmm1
movsd  %xmm1,(%rdx,%rax,8)
movsd  %xmm0,(%rdx,%rbp,8)
xorpd  %xmm0,%xmm0
cmp    %r12d,%r13d
jge    1a00 <mod_chol+0x8c0>
xorpd  %xmm0,%xmm0
mov    %r13d,%eax
cs nopw 0x0(%rax,%rax,1)
nop
lea    0x1(%rax),%ecx
imul   %ecx,%eax
shr    %eax
add    %rbp,%rax
movsd  (%r14,%rax,8),%xmm1
andpd  %xmm6,%xmm1
addsd  %xmm1,%xmm0
mov    %ecx,%eax
cmp    %r12d,%ecx
jl     19e0 <mod_chol+0x8a0>
movapd %xmm0,%xmm1
cmpunordsd %xmm0,%xmm1
movapd %xmm1,%xmm2
andpd  %xmm3,%xmm2
maxsd  %xmm0,%xmm3
andnpd %xmm3,%xmm1
orpd   %xmm2,%xmm1
mov    %r13d,%eax
imul   %ebp,%eax
shr    %eax
add    %rbp,%rax
movsd  (%r14,%rax,8),%xmm2
subsd  %xmm2,%xmm1
movapd 0x40(%rsp),%xmm5
movapd %xmm5,%xmm3
maxsd  %xmm1,%xmm3
cmpunordsd %xmm1,%xmm1
movapd %xmm1,%xmm4
andnpd %xmm3,%xmm4
andpd  %xmm5,%xmm1
orpd   %xmm4,%xmm1
xorpd  %xmm3,%xmm3
maxsd  %xmm3,%xmm1
ucomisd %xmm3,%xmm1
jbe    1a83 <mod_chol+0x943>
addsd  %xmm1,%xmm2
movsd  %xmm2,(%r14,%rax,8)
mov    0x30(%rsp),%rcx
movsd  %xmm1,(%rcx,%rbp,8)
movsd  (%r14,%rax,8),%xmm2
movapd %xmm1,0x40(%rsp)
ucomisd %xmm0,%xmm2
jne    1a8f <mod_chol+0x94f>
jnp    1900 <mod_chol+0x7c0>
cmp    %r12d,%r13d
jge    1900 <mod_chol+0x7c0>
divsd  %xmm2,%xmm0
movsd  0x5dc(%rip),%xmm1
subsd  %xmm0,%xmm1
nopl   0x0(%rax,%rax,1)
lea    0x1(%r15),%rax
mov    %eax,%ecx
imul   %r15d,%ecx
shr    %ecx
add    %rbp,%rcx
movsd  (%r14,%rcx,8),%xmm0
andpd  %xmm6,%xmm0
mulsd  %xmm1,%xmm0
addsd  (%rdx,%r15,8),%xmm0
movsd  %xmm0,(%rdx,%r15,8)
mov    %rax,%r15
cmp    %r12d,%eax
jl     1ab0 <mod_chol+0x970>
jmp    1900 <mod_chol+0x7c0>
mov    0x10(%rsp),%rsi
mov    %esi,%eax
mov    0xc(%rsp),%edx
imul   %edx,%eax
mov    %eax,%ecx
shr    $0x1f,%ecx
add    %eax,%ecx
sar    %ecx
lea    (%rcx,%rsi,1),%eax
movslq %eax,%rbp
movsd  (%r14,%rbp,8),%xmm0
imul   %edx,%r12d
mov    %r12d,%eax
shr    $0x1f,%eax
add    %r12d,%eax
sar    %eax
add    %edx,%eax
movslq %eax,%rbx
subsd  (%r14,%rbx,8),%xmm0
add    %edx,%ecx
movslq %ecx,%r15
movsd  (%r14,%r15,8),%xmm1
movsd  0x552(%rip),%xmm2
mulsd  %xmm1,%xmm2
mulsd  %xmm1,%xmm2
mulsd  %xmm0,%xmm0
addsd  %xmm2,%xmm0
xorpd  %xmm6,%xmm6
ucomisd %xmm6,%xmm0
jb     1b59 <mod_chol+0xa19>
xorps  %xmm1,%xmm1
sqrtsd %xmm0,%xmm1
jmp    1b66 <mod_chol+0xa26>
call   1060 <sqrt@plt>
xorpd  %xmm6,%xmm6
movapd %xmm0,%xmm1
movsd  (%r14,%rbp,8),%xmm0
movsd  (%r14,%rbx,8),%xmm2
addsd  %xmm0,%xmm2
movapd %xmm1,%xmm3
addsd  %xmm2,%xmm3
movsd  0x50a(%rip),%xmm4
mulsd  %xmm4,%xmm3
subsd  %xmm1,%xmm2
mulsd  %xmm4,%xmm2
subsd  %xmm2,%xmm3
mulsd  0x4d2(%rip),%xmm3
divsd  0x4f2(%rip),%xmm3
movapd 0x20(%rsp),%xmm5
movapd %xmm5,%xmm1
maxsd  %xmm3,%xmm1
cmpunordsd %xmm3,%xmm3
movapd %xmm3,%xmm4
andnpd %xmm1,%xmm4
andpd  %xmm5,%xmm3
orpd   %xmm4,%xmm3
subsd  %xmm2,%xmm3
maxsd  %xmm6,%xmm3
movapd 0x40(%rsp),%xmm1
movapd %xmm1,%xmm2
maxsd  %xmm3,%xmm2
ucomisd %xmm6,%xmm2
jbe    1c20 <mod_chol+0xae0>
addsd  %xmm2,%xmm0
movsd  %xmm0,(%r14,%rbp,8)
movsd  (%r14,%rbx,8),%xmm0
addsd  %xmm2,%xmm0
movsd  %xmm0,(%r14,%rbx,8)
movslq 0x10(%rsp),%rax
mov    0x30(%rsp),%rcx
movsd  %xmm2,(%rcx,%rax,8)
movslq 0xc(%rsp),%rax
movsd  %xmm2,(%rcx,%rax,8)
movsd  (%r14,%rbp,8),%xmm0
jmp    1c24 <mod_chol+0xae4>
movapd %xmm1,%xmm2
xorpd  %xmm3,%xmm3
ucomisd %xmm3,%xmm0
movsd  %xmm2,0x20(%rsp)
jb     1c3a <mod_chol+0xafa>
sqrtsd %xmm0,%xmm0
jmp    1c43 <mod_chol+0xb03>
call   1060 <sqrt@plt>
xorpd  %xmm3,%xmm3
movsd  %xmm0,(%r14,%rbp,8)
movsd  (%r14,%r15,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%r14,%r15,8)
movsd  (%r14,%rbx,8),%xmm0
mulsd  %xmm1,%xmm1
subsd  %xmm1,%xmm0
ucomisd %xmm3,%xmm0
jb     1c73 <mod_chol+0xb33>
sqrtsd %xmm0,%xmm0
jmp    1c78 <mod_chol+0xb38>
call   1060 <sqrt@plt>
movsd  0x20(%rsp),%xmm8
movsd  %xmm0,(%r14,%rbx,8)
jmp    11f0 <mod_chol+0xb0>

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

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