void jacobi_decompose(double cov_matrix[][3], double *eigenvalues,
                      double orth_matrix[][3]) {
  int i, j, k, l;
  int max_col[3];
  int changed[3];
  int n = 3;
  int max_row;
  int state = 0;
  double max, c, s, t, u, a;
  int count = 0;
  for (i = 0; i < n; i++) {
    max = 0;
    max_col[i] = i + 1;
    for (j = i + 1; j < n; j++) {
      if (fabs(cov_matrix[i][j]) > max) {
        max_col[i] = j;
        max = fabs(cov_matrix[i][j]);
      }
    }
  }
  for (i = 0; i < n; i++)
    for (j = 0; j < n; j++)
      orth_matrix[i][j] = (i == j) ? 1 : 0;
  for (i = 0; i < n; i++) {
    eigenvalues[i] = cov_matrix[i][i];
    changed[i] = 1;
    for (j = 0; j < n; j++)
      if (j != i && cov_matrix[i][j])
        break;
    if (j == n) {
      state--;
      changed[i] = 0;
    }
  }
  state += n;
  while (state) {
    count++;
    max = fabs(cov_matrix[0][max_col[0]]);
    max_row = 0;
    for (i = 1; i < n - 1; i++) {
      if (fabs(cov_matrix[i][max_col[i]]) > max) {
        max = fabs(cov_matrix[i][max_col[i]]);
        max_row = i;
      }
    }
    k = max_row;
    l = max_col[k];
    max = cov_matrix[k][l];
    if (max == 0)
      break;
    a = (eigenvalues[l] - eigenvalues[k]) * 0.5;
    t = fabsl(a) + sqrtl(max * max + a * a);
    s = sqrtl(max * max + t * t);
    c = t / s;
    s = max / s;
    t = max * max / t;
    if (a < 0) {
      s = -s;
      t = -t;
    }
    a = eigenvalues[k];
    eigenvalues[k] += -t;
    if (changed[k] && (fabs(-t) < 1e-6 * fabs(eigenvalues[k]))) {
      changed[k] = 0;
      state--;
    } else if (!changed[k] && (fabs(-t) > 1e-6 * fabs(eigenvalues[k]))) {
      changed[k] = 1;
      state++;
    };
    a = eigenvalues[l];
    eigenvalues[l] += t;
    if (changed[l] && (fabs(t) < 1e-6 * fabs(eigenvalues[l]))) {
      changed[l] = 0;
      state--;
    } else if (!changed[l] && (fabs(t) > 1e-6 * fabs(eigenvalues[l]))) {
      changed[l] = 1;
      state++;
    };
    cov_matrix[k][l] = 0;
    for (i = 0; i < k; i++) {
      t = cov_matrix[i][k];
      u = cov_matrix[i][l];
      cov_matrix[i][k] = t * c - s * u;
      cov_matrix[i][l] = s * t + c * u;
      if (1) {
        if (fabs(cov_matrix[i][k]) > fabs(cov_matrix[i][max_col[i]]))
          max_col[i] = k;
        if (i < 3 && fabs(cov_matrix[i][l]) > fabs(cov_matrix[i][max_col[i]]))
          max_col[i] = l;
      };
    }
    for (i = k + 1; i < l; i++) {
      t = cov_matrix[k][i];
      u = cov_matrix[i][l];
      cov_matrix[k][i] = t * c - s * u;
      cov_matrix[i][l] = s * t + c * u;
      if (1) {
        if (fabs(cov_matrix[k][i]) > fabs(cov_matrix[k][max_col[k]]))
          max_col[k] = i;
        if (i < 3 && fabs(cov_matrix[i][l]) > fabs(cov_matrix[i][max_col[i]]))
          max_col[i] = l;
      };
    }
    for (i = l + 1; i < n; i++) {
      t = cov_matrix[k][i];
      u = cov_matrix[l][i];
      cov_matrix[k][i] = t * c - s * u;
      cov_matrix[l][i] = s * t + c * u;
      if (1) {
        if (fabs(cov_matrix[k][i]) > fabs(cov_matrix[k][max_col[k]]))
          max_col[k] = i;
        if (l < 3 && fabs(cov_matrix[l][i]) > fabs(cov_matrix[l][max_col[l]]))
          max_col[l] = i;
      };
    }
    for (i = 0; i < n; i++) {
      t = orth_matrix[k][i];
      u = orth_matrix[l][i];
      orth_matrix[k][i] = t * c - s * u;
      orth_matrix[l][i] = s * t + c * u;
      if (0) {
        if (fabs(orth_matrix[k][i]) > fabs(orth_matrix[k][max_col[k]]))
          max_col[k] = i;
        if (l < 3 && fabs(orth_matrix[l][i]) > fabs(orth_matrix[l][max_col[l]]))
          max_col[l] = i;
      };
    }
  }
  for (k = 0; k < n - 1; k++) {
    for (l = k + 1; l < n; l++) {
      cov_matrix[k][l] = cov_matrix[l][k];
    }
  }
}


x86 assembly (clang, -O0):
<jacobi_decompose>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movl   $0x3,-0x44(%rbp)
movl   $0x0,-0x4c(%rbp)
movl   $0x0,-0x84(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    1204 <jacobi_decompose+0xf4>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq -0x1c(%rbp),%rax
mov    %ecx,-0x34(%rbp,%rax,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    11f1 <jacobi_decompose+0xe1>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xe64(%rip),%xmm1
pand   %xmm1,%xmm0
ucomisd -0x58(%rbp),%xmm0
jbe    11de <jacobi_decompose+0xce>
mov    -0x20(%rbp),%ecx
movslq -0x1c(%rbp),%rax
mov    %ecx,-0x34(%rbp,%rax,4)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xe2b(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
jmp    11e3 <jacobi_decompose+0xd3>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1171 <jacobi_decompose+0x61>
jmp    11f6 <jacobi_decompose+0xe6>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1146 <jacobi_decompose+0x36>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    1279 <jacobi_decompose+0x169>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    1266 <jacobi_decompose+0x156>
mov    -0x1c(%rbp),%edx
mov    -0x20(%rbp),%esi
xor    %eax,%eax
mov    $0x1,%ecx
cmp    %esi,%edx
cmove  %ecx,%eax
cvtsi2sd %eax,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    121e <jacobi_decompose+0x10e>
jmp    126b <jacobi_decompose+0x15b>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    120b <jacobi_decompose+0xfb>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    1358 <jacobi_decompose+0x248>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movslq -0x1c(%rbp),%rax
movl   $0x1,-0x40(%rbp,%rax,4)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    1324 <jacobi_decompose+0x214>
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
je     1311 <jacobi_decompose+0x201>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    130c <jacobi_decompose+0x1fc>
jp     130c <jacobi_decompose+0x1fc>
jmp    1311 <jacobi_decompose+0x201>
jmp    1324 <jacobi_decompose+0x214>
jmp    1316 <jacobi_decompose+0x206>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    12c4 <jacobi_decompose+0x1b4>
mov    -0x20(%rbp),%eax
cmp    -0x44(%rbp),%eax
jne    1345 <jacobi_decompose+0x235>
mov    -0x4c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x4c(%rbp)
movslq -0x1c(%rbp),%rax
movl   $0x0,-0x40(%rbp,%rax,4)
jmp    134a <jacobi_decompose+0x23a>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1280 <jacobi_decompose+0x170>
mov    -0x44(%rbp),%eax
add    -0x4c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
cmpl   $0x0,-0x4c(%rbp)
je     1de3 <jacobi_decompose+0xcd3>
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xc72(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0x48(%rbp)
movl   $0x1,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    142f <jacobi_decompose+0x31f>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movslq -0x34(%rbp,%rcx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xc26(%rip),%xmm1
pand   %xmm1,%xmm0
ucomisd -0x58(%rbp),%xmm0
jbe    141c <jacobi_decompose+0x30c>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movslq -0x34(%rbp,%rcx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xbf3(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x48(%rbp)
jmp    1421 <jacobi_decompose+0x311>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    13a5 <jacobi_decompose+0x295>
mov    -0x48(%rbp),%eax
mov    %eax,-0x24(%rbp)
movslq -0x24(%rbp),%rax
mov    -0x34(%rbp,%rax,4),%eax
mov    %eax,-0x28(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    147a <jacobi_decompose+0x36a>
jp     147a <jacobi_decompose+0x36a>
jmp    1de3 <jacobi_decompose+0xcd3>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
subsd  %xmm1,%xmm0
movsd  0xb74(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm1
movsd  %xmm1,-0x90(%rbp)
ff
fldl   -0x90(%rbp)
fabs
fstpt  -0xb4(%rbp)
movsd  -0x58(%rbp),%xmm0
mulsd  %xmm1,%xmm1
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
fldl   -0x98(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
call   1030 <sqrtl@plt>
fldt   -0xb4(%rbp)
faddp  %st,%st(1)
fstpl  -0x70(%rbp)
movsd  -0x58(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm1
mulsd  %xmm1,%xmm1
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
fldl   -0xa0(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
call   1030 <sqrtl@plt>
fstpl  -0xa8(%rbp)
movsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x68(%rbp)
movsd  -0x70(%rbp),%xmm0
divsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x58(%rbp),%xmm0
divsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x58(%rbp),%xmm0
mulsd  -0x58(%rbp),%xmm0
divsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
xorps  %xmm0,%xmm0
ucomisd -0x80(%rbp),%xmm0
jbe    15b7 <jacobi_decompose+0x4a7>
movsd  -0x68(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x70(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x70(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movslq -0x24(%rbp),%rax
cmpl   $0x0,-0x40(%rbp,%rax,4)
je     1675 <jacobi_decompose+0x565>
movsd  -0x70(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movaps 0x9d7(%rip),%xmm0
pand   %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movaps 0x9bf(%rip),%xmm0
pand   %xmm0,%xmm2
movsd  0x9cb(%rip),%xmm0
mulsd  %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jbe    1675 <jacobi_decompose+0x565>
movslq -0x24(%rbp),%rax
movl   $0x0,-0x40(%rbp,%rax,4)
mov    -0x4c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x4c(%rbp)
jmp    16f3 <jacobi_decompose+0x5e3>
movslq -0x24(%rbp),%rax
cmpl   $0x0,-0x40(%rbp,%rax,4)
jne    16ee <jacobi_decompose+0x5de>
movsd  -0x70(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movaps 0x959(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movaps 0x941(%rip),%xmm1
pand   %xmm1,%xmm2
movsd  0x94d(%rip),%xmm1
mulsd  %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jbe    16ee <jacobi_decompose+0x5de>
movslq -0x24(%rbp),%rax
movl   $0x1,-0x40(%rbp,%rax,4)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    16f3 <jacobi_decompose+0x5e3>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x70(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movslq -0x28(%rbp),%rax
cmpl   $0x0,-0x40(%rbp,%rax,4)
je     1783 <jacobi_decompose+0x673>
movsd  -0x70(%rbp),%xmm1
movaps 0x8c9(%rip),%xmm0
pand   %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movaps 0x8b1(%rip),%xmm0
pand   %xmm0,%xmm2
movsd  0x8bd(%rip),%xmm0
mulsd  %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jbe    1783 <jacobi_decompose+0x673>
movslq -0x28(%rbp),%rax
movl   $0x0,-0x40(%rbp,%rax,4)
mov    -0x4c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x4c(%rbp)
jmp    17ea <jacobi_decompose+0x6da>
movslq -0x28(%rbp),%rax
cmpl   $0x0,-0x40(%rbp,%rax,4)
jne    17e5 <jacobi_decompose+0x6d5>
movsd  -0x70(%rbp),%xmm0
movaps 0x862(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movaps 0x84a(%rip),%xmm1
pand   %xmm1,%xmm2
movsd  0x856(%rip),%xmm1
mulsd  %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jbe    17e5 <jacobi_decompose+0x6d5>
movslq -0x28(%rbp),%rax
movl   $0x1,-0x40(%rbp,%rax,4)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    17ea <jacobi_decompose+0x6da>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    19ae <jacobi_decompose+0x89e>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x70(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  -0x78(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x710(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movslq -0x34(%rbp,%rcx,4),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x6e8(%rip),%xmm2
pand   %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jbe    1931 <jacobi_decompose+0x821>
mov    -0x24(%rbp),%ecx
movslq -0x1c(%rbp),%rax
mov    %ecx,-0x34(%rbp,%rax,4)
cmpl   $0x3,-0x1c(%rbp)
jge    199b <jacobi_decompose+0x88b>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x6a6(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movslq -0x34(%rbp,%rcx,4),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x67e(%rip),%xmm2
pand   %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jbe    199b <jacobi_decompose+0x88b>
mov    -0x28(%rbp),%ecx
movslq -0x1c(%rbp),%rax
mov    %ecx,-0x34(%rbp,%rax,4)
jmp    19a0 <jacobi_decompose+0x890>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    180c <jacobi_decompose+0x6fc>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1b59 <jacobi_decompose+0xa49>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x70(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  -0x78(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x565(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movslq -0x34(%rbp,%rcx,4),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x53d(%rip),%xmm2
pand   %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jbe    1adc <jacobi_decompose+0x9cc>
mov    -0x1c(%rbp),%ecx
movslq -0x24(%rbp),%rax
mov    %ecx,-0x34(%rbp,%rax,4)
cmpl   $0x3,-0x1c(%rbp)
jge    1b46 <jacobi_decompose+0xa36>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x4fb(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movslq -0x34(%rbp,%rcx,4),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x4d3(%rip),%xmm2
pand   %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jbe    1b46 <jacobi_decompose+0xa36>
mov    -0x28(%rbp),%ecx
movslq -0x1c(%rbp),%rax
mov    %ecx,-0x34(%rbp,%rax,4)
jmp    1b4b <jacobi_decompose+0xa3b>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    19b7 <jacobi_decompose+0x8a7>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    1d04 <jacobi_decompose+0xbf4>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x70(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  -0x78(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x3ba(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movslq -0x34(%rbp,%rcx,4),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x392(%rip),%xmm2
pand   %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jbe    1c87 <jacobi_decompose+0xb77>
mov    -0x1c(%rbp),%ecx
movslq -0x24(%rbp),%rax
mov    %ecx,-0x34(%rbp,%rax,4)
cmpl   $0x3,-0x28(%rbp)
jge    1cf1 <jacobi_decompose+0xbe1>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x350(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movslq -0x34(%rbp,%rcx,4),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x328(%rip),%xmm2
pand   %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jbe    1cf1 <jacobi_decompose+0xbe1>
mov    -0x1c(%rbp),%ecx
movslq -0x28(%rbp),%rax
mov    %ecx,-0x34(%rbp,%rax,4)
jmp    1cf6 <jacobi_decompose+0xbe6>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1b62 <jacobi_decompose+0xa52>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    1dde <jacobi_decompose+0xcce>
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x70(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  -0x78(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1d0b <jacobi_decompose+0xbfb>
jmp    1361 <jacobi_decompose+0x251>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1e61 <jacobi_decompose+0xd51>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    1e4e <jacobi_decompose+0xd3e>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1e04 <jacobi_decompose+0xcf4>
jmp    1e53 <jacobi_decompose+0xd43>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1dea <jacobi_decompose+0xcda>
add    $0xd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<jacobi_decompose>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xc8,%rsp
mov    %rdx,0x38(%rsp)
mov    %rdi,%r15
movl   $0x1,0x20(%rsp)
movsd  0x8(%rdi),%xmm1
xorpd  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
movapd 0xeba(%rip),%xmm6
je     1150 <jacobi_decompose+0x40>
andpd  %xmm6,%xmm1
movapd %xmm1,%xmm0
movsd  0x10(%r15),%xmm1
andpd  %xmm6,%xmm1
mov    $0x1,%ebx
ucomisd %xmm0,%xmm1
jbe    1172 <jacobi_decompose+0x62>
movl   $0x2,0x20(%rsp)
mov    $0x2,%ebx
movabs $0x300000002,%rax
mov    %rax,0x24(%rsp)
movabs $0x3ff0000000000000,%rax
mov    0x38(%rsp),%rcx
mov    %rax,(%rcx)
xorpd  %xmm0,%xmm0
movupd %xmm0,0x8(%rcx)
movq   $0x0,0x18(%rcx)
mov    %rax,0x20(%rcx)
movupd %xmm0,0x28(%rcx)
movq   $0x0,0x38(%rcx)
mov    %rax,0x40(%rcx)
movsd  (%r15),%xmm0
movsd  %xmm0,(%rsi)
movl   $0x1,0x2c(%rsp)
movsd  0x8(%r15),%xmm1
movl   $0x0,0x18(%rsp)
xorpd  %xmm0,%xmm0
ucomisd %xmm0,%xmm1
jne    1202 <jacobi_decompose+0xf2>
jp     1202 <jacobi_decompose+0xf2>
movsd  0x10(%r15),%xmm1
ucomisd %xmm0,%xmm1
jne    1202 <jacobi_decompose+0xf2>
jp     1202 <jacobi_decompose+0xf2>
movl   $0x0,0x2c(%rsp)
movl   $0xffffffff,0x18(%rsp)
ff
movsd  0x20(%r15),%xmm1
movsd  %xmm1,0x8(%rsi)
movl   $0x1,0x30(%rsp)
movsd  0x18(%r15),%xmm1
ucomisd %xmm0,%xmm1
jne    1242 <jacobi_decompose+0x132>
jp     1242 <jacobi_decompose+0x132>
movsd  0x28(%r15),%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1242 <jacobi_decompose+0x132>
jp     1242 <jacobi_decompose+0x132>
addl   $0xffffffff,0x18(%rsp)
movl   $0x0,0x30(%rsp)
movsd  0x40(%r15),%xmm0
movsd  %xmm0,0x10(%rsi)
movl   $0x1,0x34(%rsp)
movsd  0x30(%r15),%xmm1
xorpd  %xmm0,%xmm0
ucomisd %xmm0,%xmm1
jne    1282 <jacobi_decompose+0x172>
jp     1282 <jacobi_decompose+0x172>
movsd  0x38(%r15),%xmm1
ucomisd %xmm0,%xmm1
jne    1282 <jacobi_decompose+0x172>
jp     1282 <jacobi_decompose+0x172>
addl   $0xffffffff,0x18(%rsp)
movl   $0x0,0x34(%rsp)
addl   $0x3,0x18(%rsp)
je     1832 <jacobi_decompose+0x722>
mov    %ebx,%eax
movsd  (%r15,%rax,8),%xmm0
andpd  %xmm6,%xmm0
movsd  0x28(%r15),%xmm1
andpd  %xmm6,%xmm1
xor    %r13d,%r13d
ucomisd %xmm0,%xmm1
seta   %r13b
mov    0x20(%rsp,%r13,4),%edx
movslq %edx,%r12
lea    0x0(%r13,%r13,2),%rcx
lea    (%r15,%rcx,8),%rcx
movsd  (%rcx,%r12,8),%xmm1
xorpd  %xmm0,%xmm0
ucomisd %xmm0,%xmm1
jne    12d5 <jacobi_decompose+0x1c5>
jnp    1832 <jacobi_decompose+0x722>
lea    (%r15,%rax,8),%rdi
lea    (%rsp,%r13,4),%r14
add    $0x20,%r14
lea    (%rcx,%r12,8),%rcx
lea    0x8(%r15),%rax
mov    %rax,0x40(%rsp)
xchg   %ax,%ax
mov    %rcx,0x50(%rsp)
mov    %rdi,0x48(%rsp)
mov    %edx,0x1c(%rsp)
movapd %xmm1,0xb0(%rsp)
movsd  (%rsi,%r12,8),%xmm2
mov    %rsi,%rbp
subsd  (%rsi,%r13,8),%xmm2
mulsd  0xd02(%rip),%xmm2
movapd %xmm2,0x90(%rsp)
movapd %xmm2,%xmm0
andpd  %xmm6,%xmm0
movlpd %xmm0,0x78(%rsp)
movapd %xmm2,%xmm0
mulsd  %xmm2,%xmm0
mulsd  %xmm1,%xmm1
movapd %xmm1,0x80(%rsp)
addsd  %xmm1,%xmm0
movsd  %xmm0,0x70(%rsp)
fldl   0x70(%rsp)
fstpt  (%rsp)
call   1030 <sqrtl@plt>
faddl  0x78(%rsp)
fstpl  0x68(%rsp)
movsd  0x68(%rsp),%xmm0
movapd %xmm0,0xa0(%rsp)
mulsd  %xmm0,%xmm0
addsd  0x80(%rsp),%xmm0
movsd  %xmm0,0x60(%rsp)
fldl   0x60(%rsp)
fstpt  (%rsp)
call   1030 <sqrtl@plt>
movapd 0x90(%rsp),%xmm5
movapd 0xb0(%rsp),%xmm9
xorpd  %xmm8,%xmm8
fstpl  0x58(%rsp)
movsd  0x58(%rsp),%xmm0
divsd  %xmm0,%xmm9
movapd 0xc4b(%rip),%xmm2
ucomisd %xmm5,%xmm8
jbe    13d1 <jacobi_decompose+0x2c1>
xorpd  %xmm2,%xmm9
movsd  0xc4f(%rip),%xmm3
movapd 0xa0(%rsp),%xmm7
movapd 0x80(%rsp),%xmm4
divsd  %xmm7,%xmm4
movapd %xmm4,%xmm1
xorpd  %xmm2,%xmm1
cmpltsd %xmm8,%xmm5
movapd %xmm5,%xmm2
andnpd %xmm4,%xmm2
andpd  %xmm1,%xmm5
orpd   %xmm2,%xmm5
mov    %rbp,%rsi
movsd  0x0(%rbp,%r13,8),%xmm1
subsd  %xmm5,%xmm1
movsd  %xmm1,0x0(%rbp,%r13,8)
cmpl   $0x0,0x2c(%rsp,%r13,4)
movapd %xmm5,%xmm2
movapd 0xbcc(%rip),%xmm6
andpd  %xmm6,%xmm2
andpd  %xmm6,%xmm1
mulsd  %xmm3,%xmm1
mov    0x1c(%rsp),%edi
mov    0x50(%rsp),%rbp
je     1460 <jacobi_decompose+0x350>
ucomisd %xmm2,%xmm1
jbe    1479 <jacobi_decompose+0x369>
mov    $0xffffffff,%ecx
xor    %eax,%eax
jmp    1470 <jacobi_decompose+0x360>
nopw   0x0(%rax,%rax,1)
mov    $0x1,%eax
ucomisd %xmm1,%xmm2
mov    $0x1,%ecx
jbe    1479 <jacobi_decompose+0x369>
mov    %eax,0x2c(%rsp,%r13,4)
add    %ecx,0x18(%rsp)
movzbl %r13b,%eax
and    $0x1,%eax
movsd  (%rsi,%r12,8),%xmm1
addsd  %xmm5,%xmm1
movsd  %xmm1,(%rsi,%r12,8)
cmpl   $0x0,0x2c(%rsp,%r12,4)
andpd  %xmm6,%xmm4
andpd  %xmm6,%xmm1
mulsd  %xmm3,%xmm1
je     14c0 <jacobi_decompose+0x3b0>
ucomisd %xmm4,%xmm1
jbe    14d9 <jacobi_decompose+0x3c9>
mov    $0xffffffff,%edx
xor    %ecx,%ecx
jmp    14d0 <jacobi_decompose+0x3c0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    $0x1,%ecx
ucomisd %xmm1,%xmm4
mov    $0x1,%edx
jbe    14d9 <jacobi_decompose+0x3c9>
mov    %ecx,0x2c(%rsp,%r12,4)
add    %edx,0x18(%rsp)
divsd  %xmm0,%xmm7
movq   $0x0,0x0(%rbp)
mov    $0x1,%ecx
test   %eax,%eax
je     1568 <jacobi_decompose+0x458>
movsd  (%r15,%r13,8),%xmm0
movsd  (%r15,%r12,8),%xmm1
movapd %xmm1,%xmm2
mulsd  %xmm9,%xmm2
movapd %xmm9,%xmm3
mulsd  %xmm0,%xmm3
mulsd  %xmm7,%xmm0
subsd  %xmm2,%xmm0
movsd  %xmm0,(%r15,%r13,8)
mulsd  %xmm7,%xmm1
addsd  %xmm3,%xmm1
movsd  %xmm1,(%r15,%r12,8)
movsd  (%r15,%r13,8),%xmm0
andpd  %xmm6,%xmm0
mov    0x48(%rsp),%rcx
movsd  (%rcx),%xmm2
andpd  %xmm6,%xmm2
ucomisd %xmm2,%xmm0
mov    $0x1,%ecx
cmova  %ecx,%ebx
andpd  %xmm6,%xmm1
movslq %ebx,%rbx
movsd  (%r15,%rbx,8),%xmm0
andpd  %xmm6,%xmm0
ucomisd %xmm0,%xmm1
cmova  %edi,%ebx
mov    $0x2,%ecx
mov    %ebx,0x20(%rsp)
cmp    %edi,%ecx
jge    1660 <jacobi_decompose+0x550>
movapd %xmm9,%xmm0
xorpd  0xa8f(%rip),%xmm0
mov    %ecx,%r11d
mov    0x1c(%rsp),%ecx
lea    (%r11,%r11,2),%rdx
lea    (%r15,%rdx,8),%rdx
lea    0x20(%rsp,%r11,4),%r8
lea    0x0(%r13,%r13,2),%rdi
lea    (%r15,%rdi,8),%r9
lea    (%r9,%r11,8),%rbx
mov    %r11,%r10
sub    %rcx,%r10
xor    %ecx,%ecx
jmp    15cc <jacobi_decompose+0x4bc>
nopl   0x0(%rax)
add    $0x18,%rdx
mov    %ecx,%eax
lea    0x1(%rcx),%rdi
add    %r11d,%eax
mov    %r10,%rbp
mov    %rdi,%rcx
add    %rdi,%rbp
je     1660 <jacobi_decompose+0x550>
movsd  (%rbx,%rcx,8),%xmm2
movsd  (%rdx,%r12,8),%xmm1
movapd %xmm1,%xmm3
mulsd  %xmm0,%xmm3
movapd %xmm9,%xmm4
mulsd  %xmm2,%xmm4
mulsd  %xmm7,%xmm2
addsd  %xmm3,%xmm2
movsd  %xmm2,(%rbx,%rcx,8)
mulsd  %xmm7,%xmm1
addsd  %xmm4,%xmm1
movsd  %xmm1,(%rdx,%r12,8)
movsd  (%rbx,%rcx,8),%xmm2
andpd  %xmm6,%xmm2
movslq (%r14),%rdi
movsd  (%r9,%rdi,8),%xmm3
andpd  %xmm6,%xmm3
ucomisd %xmm3,%xmm2
jbe    1626 <jacobi_decompose+0x516>
lea    (%r11,%rcx,1),%edi
mov    %edi,(%r14)
cmp    $0x1,%eax
ja     15b0 <jacobi_decompose+0x4a0>
andpd  %xmm6,%xmm1
movslq (%r8,%rcx,4),%rax
movsd  (%rdx,%rax,8),%xmm2
andpd  %xmm6,%xmm2
ucomisd %xmm2,%xmm1
jbe    15b0 <jacobi_decompose+0x4a0>
mov    0x1c(%rsp),%eax
mov    %eax,(%r8,%rcx,4)
jmp    15b0 <jacobi_decompose+0x4a0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movapd %xmm9,%xmm0
xorpd  0x9a3(%rip),%xmm0
cmpl   $0x1,0x1c(%rsp)
jg     1740 <jacobi_decompose+0x630>
lea    0x1(%r12),%rax
lea    0x0(,%r13,2),%rcx
add    %r13,%rcx
lea    (%r15,%rcx,8),%rcx
mov    %r12,%rdx
shl    $0x5,%rdx
add    0x40(%rsp),%rdx
jmp    16b2 <jacobi_decompose+0x5a2>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rax
add    $0x8,%rdx
cmp    $0x3,%rax
je     1740 <jacobi_decompose+0x630>
movsd  (%rcx,%rax,8),%xmm2
movsd  (%rdx),%xmm1
movapd %xmm1,%xmm3
mulsd  %xmm0,%xmm3
movapd %xmm9,%xmm4
mulsd  %xmm2,%xmm4
mulsd  %xmm7,%xmm2
addsd  %xmm3,%xmm2
movsd  %xmm2,(%rcx,%rax,8)
mulsd  %xmm7,%xmm1
addsd  %xmm4,%xmm1
movsd  %xmm1,(%rdx)
movsd  (%rcx,%rax,8),%xmm2
andpd  %xmm6,%xmm2
movslq (%r14),%rdi
movsd  (%rcx,%rdi,8),%xmm3
andpd  %xmm6,%xmm3
ucomisd %xmm3,%xmm2
jbe    1703 <jacobi_decompose+0x5f3>
mov    %eax,(%r14)
andpd  %xmm6,%xmm1
movslq 0x20(%rsp,%r12,4),%rbp
lea    (%r12,%r12,2),%rdi
lea    (%r15,%rdi,8),%rdi
movsd  (%rdi,%rbp,8),%xmm2
andpd  %xmm6,%xmm2
ucomisd %xmm2,%xmm1
jbe    16a0 <jacobi_decompose+0x590>
mov    %eax,0x20(%rsp,%r12,4)
jmp    16a0 <jacobi_decompose+0x590>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    0x0(,%r13,2),%rcx
add    %r13,%rcx
lea    (%r12,%r12,2),%rax
mov    0x38(%rsp),%rdx
movupd (%rdx,%rax,8),%xmm1
movupd (%rdx,%rcx,8),%xmm2
movapd %xmm0,%xmm3
unpcklpd %xmm0,%xmm3
mulpd  %xmm1,%xmm3
movapd %xmm7,%xmm4
unpcklpd %xmm7,%xmm4
movapd %xmm9,%xmm5
unpcklpd %xmm9,%xmm5
mulpd  %xmm2,%xmm5
mulpd  %xmm4,%xmm2
addpd  %xmm3,%xmm2
movupd %xmm2,(%rdx,%rcx,8)
mulpd  %xmm1,%xmm4
addpd  %xmm4,%xmm5
movupd %xmm5,(%rdx,%rax,8)
movsd  0x10(%rdx,%rcx,8),%xmm1
movsd  0x10(%rdx,%rax,8),%xmm2
mulsd  %xmm2,%xmm0
mulsd  %xmm1,%xmm9
mulsd  %xmm7,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%rdx,%rcx,8)
mulsd  %xmm2,%xmm7
addsd  %xmm9,%xmm7
movsd  %xmm7,0x10(%rdx,%rax,8)
cmpl   $0x0,0x18(%rsp)
je     1832 <jacobi_decompose+0x722>
movslq 0x20(%rsp),%rbx
movslq 0x24(%rsp),%rax
movsd  (%r15,%rbx,8),%xmm0
andpd  %xmm6,%xmm0
movsd  0x18(%r15,%rax,8),%xmm1
andpd  %xmm6,%xmm1
xor    %r13d,%r13d
ucomisd %xmm0,%xmm1
lea    (%r15,%rbx,8),%rdi
seta   %r13b
lea    0x20(%rsp,%r13,4),%r14
mov    0x20(%rsp,%r13,4),%edx
movslq %edx,%r12
lea    0x0(%r13,%r13,2),%rax
lea    (%r15,%rax,8),%rax
lea    (%rax,%r12,8),%rcx
movsd  (%rax,%r12,8),%xmm1
ucomisd %xmm8,%xmm1
jne    12f0 <jacobi_decompose+0x1e0>
jp     12f0 <jacobi_decompose+0x1e0>
movsd  0x18(%r15),%xmm0
movsd  0x30(%r15),%xmm1
movsd  %xmm0,0x8(%r15)
movsd  %xmm1,0x10(%r15)
movsd  0x38(%r15),%xmm0
movsd  %xmm0,0x28(%r15)
add    $0xc8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @jacobi_decompose([3 x double]* nocapture %0, double* nocapture %1, [3 x double]* nocapture %2) {
%4 = alloca [3 x i32]
%5 = alloca [3 x i32]
%6 = bitcast [3 x i32]* %4 to i8*
%7 = bitcast [3 x i32]* %5 to i8*
%8 = getelementptr inbounds [3 x i32], [3 x i32]* %4, i64 0, i64 0
store i32 1, i32* %8
%9 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 0, i64 1
%10 = load double, double* %9
%11 = fcmp ueq double %10, 0.000000e+00
%12 = tail call double @llvm.fabs.f64(double %10)
%13 = select i1 %11, double 0.000000e+00, double %12
%14 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 0, i64 2
%15 = load double, double* %14
%16 = tail call double @llvm.fabs.f64(double %15)
%17 = fcmp ogt double %16, %13
br i1 %17, label %35, label %18
18: ; preds = %35, %3
%19 = phi i32 [ 2, %35 ], [ 1, %3 ]
%20 = getelementptr inbounds [3 x i32], [3 x i32]* %4, i64 0, i64 1
store i32 2, i32* %20
%21 = getelementptr inbounds [3 x i32], [3 x i32]* %4, i64 0, i64 2
store i32 3, i32* %21
%22 = getelementptr inbounds [3 x double], [3 x double]* %2, i64 0, i64 0
store double 1.000000e+00, double* %22
%23 = getelementptr inbounds [3 x double], [3 x double]* %2, i64 0, i64 1
%24 = getelementptr inbounds [3 x double], [3 x double]* %2, i64 1, i64 1
%25 = bitcast double* %23 to i8*
store double 1.000000e+00, double* %24
%26 = getelementptr inbounds [3 x double], [3 x double]* %2, i64 1, i64 2
%27 = getelementptr inbounds [3 x double], [3 x double]* %2, i64 2, i64 2
%28 = bitcast double* %26 to i8*
store double 1.000000e+00, double* %27
%29 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 0, i64 0
%30 = load double, double* %29
store double %30, double* %1
%31 = getelementptr inbounds [3 x i32], [3 x i32]* %5, i64 0, i64 0
store i32 1, i32* %31
%32 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 0, i64 1
%33 = load double, double* %32
%34 = fcmp une double %33, 0.000000e+00
br i1 %34, label %41, label %36
35: ; preds = %3
store i32 2, i32* %8
br label %18
36: ; preds = %18
%37 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 0, i64 2
%38 = load double, double* %37
%39 = fcmp une double %38, 0.000000e+00
br i1 %39, label %41, label %40
40: ; preds = %36
store i32 0, i32* %31
br label %41
41: ; preds = %40, %36, %18
%42 = phi i32 [ -1, %40 ], [ 0, %36 ], [ 0, %18 ]
%43 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 1, i64 1
%44 = load double, double* %43
%45 = getelementptr inbounds double, double* %1, i64 1
store double %44, double* %45
%46 = getelementptr inbounds [3 x i32], [3 x i32]* %5, i64 0, i64 1
store i32 1, i32* %46
%47 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 1, i64 0
%48 = load double, double* %47
%49 = fcmp une double %48, 0.000000e+00
br i1 %49, label %56, label %50
50: ; preds = %41
%51 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 1, i64 2
%52 = load double, double* %51
%53 = fcmp une double %52, 0.000000e+00
br i1 %53, label %56, label %54
54: ; preds = %50
%55 = add nsw i32 %42, -1
store i32 0, i32* %46
br label %56
56: ; preds = %54, %50, %41
%57 = phi i32 [ %55, %54 ], [ %42, %50 ], [ %42, %41 ]
%58 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 2, i64 2
%59 = load double, double* %58
%60 = getelementptr inbounds double, double* %1, i64 2
store double %59, double* %60
%61 = getelementptr inbounds [3 x i32], [3 x i32]* %5, i64 0, i64 2
store i32 1, i32* %61
%62 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 2, i64 0
%63 = load double, double* %62
%64 = fcmp une double %63, 0.000000e+00
br i1 %64, label %71, label %65
65: ; preds = %56
%66 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 2, i64 1
%67 = load double, double* %66
%68 = fcmp une double %67, 0.000000e+00
br i1 %68, label %71, label %69
69: ; preds = %65
%70 = add nsw i32 %57, -1
store i32 0, i32* %61
br label %71
71: ; preds = %56, %65, %69
%72 = phi i32 [ %70, %69 ], [ %57, %65 ], [ %57, %56 ]
%73 = add nsw i32 %72, 3
%74 = icmp eq i32 %73, 0
br i1 %74, label %321, label %75
75: ; preds = %71
%76 = zext i32 %19 to i64
%77 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 0, i64 %76
%78 = load double, double* %77
%79 = tail call double @llvm.fabs.f64(double %78)
%80 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 1, i64 2
%81 = load double, double* %80
%82 = tail call double @llvm.fabs.f64(double %81)
%83 = fcmp ogt double %82, %79
%84 = zext i1 %83 to i64
%85 = getelementptr inbounds [3 x i32], [3 x i32]* %4, i64 0, i64 %84
%86 = load i32, i32* %85
%87 = sext i32 %86 to i64
%88 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 %84, i64 %87
%89 = load double, double* %88
%90 = fcmp oeq double %89, 0.000000e+00
br i1 %90, label %321, label %91
91: ; preds = %75, %269
%92 = phi double [ %286, %269 ], [ %89, %75 ]
%93 = phi double* [ %285, %269 ], [ %88, %75 ]
%94 = phi i64 [ %284, %269 ], [ %87, %75 ]
%95 = phi i32 [ %283, %269 ], [ %86, %75 ]
%96 = phi i32* [ %282, %269 ], [ %85, %75 ]
%97 = phi i64 [ %281, %269 ], [ %84, %75 ]
%98 = phi i1 [ %280, %269 ], [ %83, %75 ]
%99 = phi double* [ %273, %269 ], [ %77, %75 ]
%100 = phi i32 [ %167, %269 ], [ %73, %75 ]
%101 = phi i32 [ %270, %269 ], [ %19, %75 ]
%102 = zext i1 %98 to i32
%103 = getelementptr inbounds double, double* %1, i64 %94
%104 = load double, double* %103
%105 = getelementptr inbounds double, double* %1, i64 %97
%106 = load double, double* %105
%107 = fsub double %104, %106
%108 = fmul double %107, 5.000000e-01
%109 = tail call double @llvm.fabs.f64(double %108)
%110 = fpext double %109 to x86_fp80
%111 = fmul double %108, %108
%112 = tail call double @llvm.fmuladd.f64(double %92, double %92, double %111)
%113 = fpext double %112 to x86_fp80
%114 = tail call x86_fp80 @sqrtl(x86_fp80 %113)
%115 = fadd x86_fp80 %114, %110
%116 = fptrunc x86_fp80 %115 to double
%117 = fmul double %116, %116
%118 = tail call double @llvm.fmuladd.f64(double %92, double %92, double %117)
%119 = fpext double %118 to x86_fp80
%120 = tail call x86_fp80 @sqrtl(x86_fp80 %119)
%121 = fptrunc x86_fp80 %120 to double
%122 = fdiv double %116, %121
%123 = fdiv double %92, %121
%124 = fmul double %92, %92
%125 = fdiv double %124, %116
%126 = fcmp olt double %108, 0.000000e+00
%127 = fneg double %123
%128 = fneg double %125
%129 = select i1 %126, double %127, double %123
%130 = select i1 %126, double %128, double %125
%131 = fneg double %130
%132 = load double, double* %105
%133 = fsub double %132, %130
store double %133, double* %105
%134 = getelementptr inbounds [3 x i32], [3 x i32]* %5, i64 0, i64 %97
%135 = load i32, i32* %134
%136 = icmp eq i32 %135, 0
%137 = tail call double @llvm.fabs.f64(double %131)
%138 = tail call double @llvm.fabs.f64(double %133)
%139 = fmul double %138, 0x3EB0C6F7A0B5ED8D
br i1 %136, label %142, label %140
140: ; preds = %91
%141 = fcmp olt double %137, %139
br i1 %141, label %144, label %148
142: ; preds = %91
%143 = fcmp ogt double %137, %139
br i1 %143, label %144, label %148
144: ; preds = %142, %140
%145 = phi i32 [ 0, %140 ], [ 1, %142 ]
%146 = phi i32 [ -1, %140 ], [ 1, %142 ]
store i32 %145, i32* %134
%147 = add nsw i32 %100, %146
br label %148
148: ; preds = %144, %140, %142
%149 = phi i32 [ %100, %142 ], [ %100, %140 ], [ %147, %144 ]
%150 = load double, double* %103
%151 = fadd double %130, %150
store double %151, double* %103
%152 = getelementptr inbounds [3 x i32], [3 x i32]* %5, i64 0, i64 %94
%153 = load i32, i32* %152
%154 = icmp eq i32 %153, 0
%155 = tail call double @llvm.fabs.f64(double %125)
%156 = tail call double @llvm.fabs.f64(double %151)
%157 = fmul double %156, 0x3EB0C6F7A0B5ED8D
br i1 %154, label %160, label %158
158: ; preds = %148
%159 = fcmp olt double %155, %157
br i1 %159, label %162, label %166
160: ; preds = %148
%161 = fcmp ogt double %155, %157
br i1 %161, label %162, label %166
162: ; preds = %160, %158
%163 = phi i32 [ 0, %158 ], [ 1, %160 ]
%164 = phi i32 [ -1, %158 ], [ 1, %160 ]
store i32 %163, i32* %152
%165 = add nsw i32 %149, %164
br label %166
166: ; preds = %162, %158, %160
%167 = phi i32 [ %149, %160 ], [ %149, %158 ], [ %165, %162 ]
store double 0.000000e+00, double* %93
br i1 %98, label %168, label %191
168: ; preds = %166
%169 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 0, i64 %97
%170 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 0, i64 %94
%171 = fneg double %129
%172 = load double, double* %169
%173 = load double, double* %170
%174 = fmul double %173, %171
%175 = tail call double @llvm.fmuladd.f64(double %172, double %122, double %174)
store double %175, double* %169
%176 = fmul double %122, %173
%177 = tail call double @llvm.fmuladd.f64(double %129, double %172, double %176)
store double %177, double* %170
%178 = load double, double* %169
%179 = tail call double @llvm.fabs.f64(double %178)
%180 = load double, double* %99
%181 = tail call double @llvm.fabs.f64(double %180)
%182 = fcmp ogt double %179, %181
%183 = select i1 %182, i32 1, i32 %101
%184 = tail call double @llvm.fabs.f64(double %177)
%185 = sext i32 %183 to i64
%186 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 0, i64 %185
%187 = load double, double* %186
%188 = tail call double @llvm.fabs.f64(double %187)
%189 = fcmp ogt double %184, %188
%190 = select i1 %189, i32 %95, i32 %183
br label %191
191: ; preds = %168, %166
%192 = phi i32 [ 1, %166 ], [ 2, %168 ]
%193 = phi i32 [ %101, %166 ], [ %190, %168 ]
store i32 %193, i32* %8
%194 = icmp slt i32 %192, %95
br i1 %194, label %195, label %199
195: ; preds = %191
%196 = fneg double %129
%197 = zext i32 %192 to i64
%198 = zext i32 %95 to i64
br label %204
199: ; preds = %237, %191
%200 = icmp slt i32 %95, 2
%201 = fneg double %129
br i1 %200, label %202, label %241
202: ; preds = %199
%203 = getelementptr inbounds [3 x i32], [3 x i32]* %4, i64 0, i64 %94
br label %288
204: ; preds = %195, %237
%205 = phi i64 [ %197, %195 ], [ %238, %237 ]
%206 = phi i32 [ %102, %195 ], [ %239, %237 ]
%207 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 %97, i64 %205
%208 = load double, double* %207
%209 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 %205, i64 %94
%210 = load double, double* %209
%211 = fmul double %210, %196
%212 = tail call double @llvm.fmuladd.f64(double %208, double %122, double %211)
store double %212, double* %207
%213 = fmul double %122, %210
%214 = tail call double @llvm.fmuladd.f64(double %129, double %208, double %213)
store double %214, double* %209
%215 = load double, double* %207
%216 = tail call double @llvm.fabs.f64(double %215)
%217 = load i32, i32* %96
%218 = sext i32 %217 to i64
%219 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 %97, i64 %218
%220 = load double, double* %219
%221 = tail call double @llvm.fabs.f64(double %220)
%222 = fcmp ogt double %216, %221
br i1 %222, label %223, label %225
223: ; preds = %204
%224 = trunc i64 %205 to i32
store i32 %224, i32* %96
br label %225
225: ; preds = %223, %204
%226 = icmp ult i32 %206, 2
br i1 %226, label %227, label %237
227: ; preds = %225
%228 = tail call double @llvm.fabs.f64(double %214)
%229 = getelementptr inbounds [3 x i32], [3 x i32]* %4, i64 0, i64 %205
%230 = load i32, i32* %229
%231 = sext i32 %230 to i64
%232 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 %205, i64 %231
%233 = load double, double* %232
%234 = tail call double @llvm.fabs.f64(double %233)
%235 = fcmp ogt double %228, %234
br i1 %235, label %236, label %237
236: ; preds = %227
store i32 %95, i32* %229
br label %237
237: ; preds = %225, %227, %236
%238 = add nuw nsw i64 %205, 1
%239 = trunc i64 %205 to i32
%240 = icmp eq i64 %238, %198
br i1 %240, label %199, label %204
241: ; preds = %319, %199
%242 = getelementptr inbounds [3 x double], [3 x double]* %2, i64 %97, i64 0
%243 = getelementptr inbounds [3 x double], [3 x double]* %2, i64 %94, i64 0
%244 = bitcast double* %243 to <2 x double>*
%245 = load <2 x double>, <2 x double>* %244
%246 = bitcast double* %242 to <2 x double>*
%247 = load <2 x double>, <2 x double>* %246
%248 = insertelement <2 x double> poison, double %201, i64 0
%249 = shufflevector <2 x double> %248, <2 x double> poison, <2 x i32> zeroinitializer
%250 = fmul <2 x double> %245, %249
%251 = insertelement <2 x double> poison, double %122, i64 0
%252 = shufflevector <2 x double> %251, <2 x double> poison, <2 x i32> zeroinitializer
%253 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %247, <2 x double> %252, <2 x double> %250)
%254 = bitcast double* %242 to <2 x double>*
store <2 x double> %253, <2 x double>* %254
%255 = fmul <2 x double> %252, %245
%256 = insertelement <2 x double> poison, double %129, i64 0
%257 = shufflevector <2 x double> %256, <2 x double> poison, <2 x i32> zeroinitializer
%258 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %257, <2 x double> %247, <2 x double> %255)
%259 = bitcast double* %243 to <2 x double>*
store <2 x double> %258, <2 x double>* %259
%260 = getelementptr inbounds [3 x double], [3 x double]* %2, i64 %97, i64 2
%261 = load double, double* %260
%262 = getelementptr inbounds [3 x double], [3 x double]* %2, i64 %94, i64 2
%263 = load double, double* %262
%264 = fmul double %263, %201
%265 = tail call double @llvm.fmuladd.f64(double %261, double %122, double %264)
store double %265, double* %260
%266 = fmul double %122, %263
%267 = tail call double @llvm.fmuladd.f64(double %129, double %261, double %266)
store double %267, double* %262
%268 = icmp eq i32 %167, 0
br i1 %268, label %321, label %269
269: ; preds = %241
%270 = load i32, i32* %8
%271 = load i32, i32* %20
%272 = sext i32 %270 to i64
%273 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 0, i64 %272
%274 = load double, double* %273
%275 = tail call double @llvm.fabs.f64(double %274)
%276 = sext i32 %271 to i64
%277 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 1, i64 %276
%278 = load double, double* %277
%279 = tail call double @llvm.fabs.f64(double %278)
%280 = fcmp ogt double %279, %275
%281 = zext i1 %280 to i64
%282 = getelementptr inbounds [3 x i32], [3 x i32]* %4, i64 0, i64 %281
%283 = load i32, i32* %282
%284 = sext i32 %283 to i64
%285 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 %281, i64 %284
%286 = load double, double* %285
%287 = fcmp oeq double %286, 0.000000e+00
br i1 %287, label %321, label %91
288: ; preds = %202, %319
%289 = phi i64 [ %94, %202 ], [ %290, %319 ]
%290 = add nsw i64 %289, 1
%291 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 %97, i64 %290
%292 = load double, double* %291
%293 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 %94, i64 %290
%294 = load double, double* %293
%295 = fmul double %294, %201
%296 = tail call double @llvm.fmuladd.f64(double %292, double %122, double %295)
store double %296, double* %291
%297 = fmul double %122, %294
%298 = tail call double @llvm.fmuladd.f64(double %129, double %292, double %297)
store double %298, double* %293
%299 = load double, double* %291
%300 = tail call double @llvm.fabs.f64(double %299)
%301 = load i32, i32* %96
%302 = sext i32 %301 to i64
%303 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 %97, i64 %302
%304 = load double, double* %303
%305 = tail call double @llvm.fabs.f64(double %304)
%306 = fcmp ogt double %300, %305
br i1 %306, label %307, label %309
307: ; preds = %288
%308 = trunc i64 %290 to i32
store i32 %308, i32* %96
br label %309
309: ; preds = %288, %307
%310 = tail call double @llvm.fabs.f64(double %298)
%311 = load i32, i32* %203
%312 = sext i32 %311 to i64
%313 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 %94, i64 %312
%314 = load double, double* %313
%315 = tail call double @llvm.fabs.f64(double %314)
%316 = fcmp ogt double %310, %315
br i1 %316, label %317, label %319
317: ; preds = %309
%318 = trunc i64 %290 to i32
store i32 %318, i32* %203
br label %319
319: ; preds = %309, %317
%320 = icmp eq i64 %290, 2
br i1 %320, label %241, label %288
321: ; preds = %269, %241, %75, %71
%322 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 1, i64 0
%323 = load double, double* %322
%324 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 0, i64 1
store double %323, double* %324
%325 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 2, i64 0
%326 = load double, double* %325
%327 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 0, i64 2
store double %326, double* %327
%328 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 2, i64 1
%329 = load double, double* %328
%330 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 1, i64 2
store double %329, double* %330
ret void
}