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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
scalar_t__ fabs(double);
double sqrt(double);
void make_symmetric_matrix_triangular(double **a, int n, double *d, double *e) {
  int i, j, k;
  double f, g, h, hh, scale;
  for (i = n - 1; i >= 1; i--) {
    h = scale = 0;
    if (i > 1) {
      for (k = 0; k < i; k++)
        scale += fabs(a[i][k]);
      if ((((scale) != (scale)) || ((0.) != (0.))
               ? (((scale) != (scale)) && ((0.) != (0.)) ? 1 : 0)
               : !(scale < 0. || 0. < scale)))
        e[i] = a[i][i - 1];
      else {
        for (k = 0; k < i; k++) {
          a[i][k] /= scale;
          h += a[i][k] * a[i][k];
        }
        f = a[i][i - 1];
        g = f >= 0 ? -sqrt(h) : sqrt(h);
        e[i] = scale * g;
        h -= f * g;
        a[i][i - 1] = f - g;
        f = 0;
        for (j = 0; j < i; j++) {
          a[j][i] = a[i][j] / h;
          g = 0;
          for (k = 0; k <= j; k++)
            g += a[j][k] * a[i][k];
          for (k = j + 1; k < i; k++)
            g += a[k][j] * a[i][k];
          e[j] = g / h;
          f += e[j] * a[i][j];
        }
        hh = f / (2 * h);
        for (j = 0; j < i; j++) {
          f = a[i][j];
          e[j] = g = e[j] - hh * f;
          for (k = 0; k <= j; k++)
            a[j][k] -= f * e[k] + g * a[i][k];
        }
      }
    } else
      e[i] = a[i][i - 1];
    d[i] = h;
  }
  d[0] = e[0] = 0;
  for (i = 0; i < n; i++) {
    if (fabs(d[i]) > 0) {
      for (j = 0; j < i; j++) {
        g = 0;
        for (k = 0; k < i; k++)
          g += a[i][k] * a[k][j];
        for (k = 0; k < i; k++)
          a[k][j] -= g * a[k][i];
      }
    }
    d[i] = a[i][i];
    a[i][i] = 1;
    for (j = 0; j < i; j++)
      a[j][i] = a[i][j] = 0;
  }
}


x86 assembly (clang, -O0):
<make_symmetric_matrix_triangular>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x1,-0x24(%rbp)
jl     168e <make_symmetric_matrix_triangular+0x56e>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
cmpl   $0x1,-0x24(%rbp)
jle    1647 <make_symmetric_matrix_triangular+0x527>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    11ae <make_symmetric_matrix_triangular+0x8e>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1030 <fabs@plt>
cvtsi2sd %rax,%xmm0
addsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    116b <make_symmetric_matrix_triangular+0x4b>
movsd  -0x58(%rbp),%xmm0
ucomisd -0x58(%rbp),%xmm0
jne    11c9 <make_symmetric_matrix_triangular+0xa9>
jp     11c9 <make_symmetric_matrix_triangular+0xa9>
jmp    1211 <make_symmetric_matrix_triangular+0xf1>
movsd  -0x58(%rbp),%xmm0
ucomisd -0x58(%rbp),%xmm0
jne    11e4 <make_symmetric_matrix_triangular+0xc4>
jp     11e4 <make_symmetric_matrix_triangular+0xc4>
jmp    1202 <make_symmetric_matrix_triangular+0xe2>
xor    %eax,%eax
test   $0x1,%al
jne    11f3 <make_symmetric_matrix_triangular+0xd3>
jmp    1202 <make_symmetric_matrix_triangular+0xe2>
mov    $0x1,%al
test   $0x1,%al
jne    1231 <make_symmetric_matrix_triangular+0x111>
jmp    125d <make_symmetric_matrix_triangular+0x13d>
xor    %eax,%eax
test   $0x1,%al
jne    1231 <make_symmetric_matrix_triangular+0x111>
jmp    125d <make_symmetric_matrix_triangular+0x13d>
xorps  %xmm0,%xmm0
ucomisd -0x58(%rbp),%xmm0
ja     125d <make_symmetric_matrix_triangular+0x13d>
movsd  -0x58(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
ja     125d <make_symmetric_matrix_triangular+0x13d>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1642 <make_symmetric_matrix_triangular+0x522>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    12dd <make_symmetric_matrix_triangular+0x1bd>
movsd  -0x58(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x48(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1264 <make_symmetric_matrix_triangular+0x144>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x38(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1339 <make_symmetric_matrix_triangular+0x219>
movsd  -0x48(%rbp),%xmm0
call   1040 <sqrt@plt>
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x60(%rbp)
jmp    1348 <make_symmetric_matrix_triangular+0x228>
movsd  -0x48(%rbp),%xmm0
call   1040 <sqrt@plt>
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x58(%rbp),%xmm0
mulsd  -0x40(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x38(%rbp),%xmm0
movsd  -0x40(%rbp),%xmm2
movsd  -0x48(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x38(%rbp),%xmm0
subsd  -0x40(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1527 <make_symmetric_matrix_triangular+0x407>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x48(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jg     146f <make_symmetric_matrix_triangular+0x34f>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x40(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1419 <make_symmetric_matrix_triangular+0x2f9>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    14ce <make_symmetric_matrix_triangular+0x3ae>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x40(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1478 <make_symmetric_matrix_triangular+0x358>
movsd  -0x40(%rbp),%xmm0
divsd  -0x48(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x38(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    13cf <make_symmetric_matrix_triangular+0x2af>
movsd  -0x38(%rbp),%xmm0
movsd  0xad4(%rip),%xmm1
mulsd  -0x48(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    163d <make_symmetric_matrix_triangular+0x51d>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x50(%rbp),%xmm0
movsd  -0x38(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jg     162a <make_symmetric_matrix_triangular+0x50a>
movsd  -0x38(%rbp),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x40(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    15be <make_symmetric_matrix_triangular+0x49e>
jmp    162f <make_symmetric_matrix_triangular+0x50f>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1549 <make_symmetric_matrix_triangular+0x429>
jmp    1642 <make_symmetric_matrix_triangular+0x522>
jmp    166e <make_symmetric_matrix_triangular+0x54e>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    1140 <make_symmetric_matrix_triangular+0x20>
mov    -0x20(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
mov    -0x18(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    187a <make_symmetric_matrix_triangular+0x75a>
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1030 <fabs@plt>
cmp    $0x0,%rax
jle    17d7 <make_symmetric_matrix_triangular+0x6b7>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    17d2 <make_symmetric_matrix_triangular+0x6b2>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    174b <make_symmetric_matrix_triangular+0x62b>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x40(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    16f5 <make_symmetric_matrix_triangular+0x5d5>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    17bf <make_symmetric_matrix_triangular+0x69f>
movsd  -0x40(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1752 <make_symmetric_matrix_triangular+0x632>
jmp    17c4 <make_symmetric_matrix_triangular+0x6a4>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    16da <make_symmetric_matrix_triangular+0x5ba>
jmp    17d7 <make_symmetric_matrix_triangular+0x6b7>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsd  0x7ef(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1867 <make_symmetric_matrix_triangular+0x747>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    181d <make_symmetric_matrix_triangular+0x6fd>
jmp    186c <make_symmetric_matrix_triangular+0x74c>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    16ab <make_symmetric_matrix_triangular+0x58b>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<make_symmetric_matrix_triangular>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    %rcx,%r15
mov    %rdx,0x18(%rsp)
mov    %rdi,%r14
mov    %esi,%eax
mov    %rax,0x38(%rsp)
mov    %rsi,0x30(%rsp)
cmp    $0x2,%esi
jl     1795 <make_symmetric_matrix_triangular+0x675>
movabs $0x100000000,%r12
mov    0x30(%rsp),%rax
lea    -0x1(%rax),%ecx
mov    %rcx,%rax
neg    %rax
mov    %rax,0x50(%rsp)
lea    0x8(%r14),%rax
mov    %rax,0x48(%rsp)
mov    0x38(%rsp),%rdx
mov    %rcx,%rax
mov    %rcx,0x58(%rsp)
xor    %eax,%eax
mov    %rcx,0x10(%rsp)
jmp    11cd <make_symmetric_matrix_triangular+0xad>
nopw   0x0(%rax,%rax,1)
mov    0x28(%rsp),%rcx
movsd  -0x10(%rax,%rcx,8),%xmm0
movsd  %xmm0,(%r15,%rbx,8)
xorpd  %xmm9,%xmm9
mov    0x18(%rsp),%rax
movsd  %xmm9,(%rax,%rbx,8)
addq   $0xffffffffffffffff,0x10(%rsp)
mov    0x60(%rsp),%rax
add    $0x1,%rax
cmp    $0x2,%rcx
mov    %rbx,%rdx
jle    1795 <make_symmetric_matrix_triangular+0x675>
lea    -0x1(%rdx),%rbx
cmp    $0x2,%rdx
je     177a <make_symmetric_matrix_triangular+0x65a>
mov    %rdx,0x28(%rsp)
mov    %rax,0x60(%rsp)
mov    %rax,%rcx
not    %rcx
mov    0x58(%rsp),%rax
mov    %rcx,0x20(%rsp)
add    %rcx,%rax
cmp    $0x3,%rax
jae    1210 <make_symmetric_matrix_triangular+0xf0>
xorpd  %xmm4,%xmm4
xor    %ebp,%ebp
jmp    12b8 <make_symmetric_matrix_triangular+0x198>
nopl   0x0(%rax)
mov    0x10(%rsp),%r13
and    $0xfffffffffffffffc,%r13
xorps  %xmm4,%xmm4
xor    %ebp,%ebp
xchg   %ax,%ax
movsd  %xmm4,0x8(%rsp)
mov    (%r14,%rbx,8),%rax
movsd  (%rax,%rbp,8),%xmm0
call   1030 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
addsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
mov    (%r14,%rbx,8),%rax
movsd  0x8(%rax,%rbp,8),%xmm0
call   1030 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
addsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
mov    (%r14,%rbx,8),%rax
movsd  0x10(%rax,%rbp,8),%xmm0
call   1030 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
addsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
mov    (%r14,%rbx,8),%rax
movsd  0x18(%rax,%rbp,8),%xmm0
call   1030 <fabs@plt>
xorps  %xmm4,%xmm4
cvtsi2sd %rax,%xmm4
addsd  0x8(%rsp),%xmm4
add    $0x4,%rbp
cmp    %rbp,%r13
jne    1220 <make_symmetric_matrix_triangular+0x100>
testb  $0x3,0x10(%rsp)
je     1300 <make_symmetric_matrix_triangular+0x1e0>
mov    0x10(%rsp),%r13
and    $0x3,%r13d
nopl   0x0(%rax,%rax,1)
movsd  %xmm4,0x8(%rsp)
mov    (%r14,%rbx,8),%rax
movsd  (%rax,%rbp,8),%xmm0
call   1030 <fabs@plt>
movsd  0x8(%rsp),%xmm4
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
addsd  %xmm0,%xmm4
add    $0x1,%rbp
add    $0xffffffffffffffff,%r13
jne    12d0 <make_symmetric_matrix_triangular+0x1b0>
ucomisd 0xd08(%rip),%xmm4
mov    (%r14,%rbx,8),%rax
jne    1314 <make_symmetric_matrix_triangular+0x1f4>
jnp    1190 <make_symmetric_matrix_triangular+0x70>
mov    0x20(%rsp),%rcx
cmp    0x50(%rsp),%rcx
mov    0x28(%rsp),%rbp
jne    132e <make_symmetric_matrix_triangular+0x20e>
xorpd  %xmm9,%xmm9
xor    %ecx,%ecx
jmp    1381 <make_symmetric_matrix_triangular+0x261>
mov    0x10(%rsp),%rdx
and    $0xfffffffffffffffe,%rdx
xorpd  %xmm0,%xmm0
xor    %ecx,%ecx
nopl   (%rax)
movsd  (%rax,%rcx,8),%xmm1
movsd  0x8(%rax,%rcx,8),%xmm9
divsd  %xmm4,%xmm1
movsd  %xmm1,(%rax,%rcx,8)
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
divsd  %xmm4,%xmm9
movsd  %xmm9,0x8(%rax,%rcx,8)
mulsd  %xmm9,%xmm9
addsd  %xmm1,%xmm9
add    $0x2,%rcx
movapd %xmm9,%xmm0
cmp    %rcx,%rdx
jne    1340 <make_symmetric_matrix_triangular+0x220>
testb  $0x1,0x10(%rsp)
je     139f <make_symmetric_matrix_triangular+0x27f>
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm4,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm9
movsd  -0x10(%rax,%rbp,8),%xmm1
ucomisd 0xc62(%rip),%xmm9
jb     13ba <make_symmetric_matrix_triangular+0x29a>
xorps  %xmm0,%xmm0
sqrtsd %xmm9,%xmm0
jmp    13ea <make_symmetric_matrix_triangular+0x2ca>
movapd %xmm9,%xmm0
movsd  %xmm9,0x20(%rsp)
movsd  %xmm4,0x8(%rsp)
movsd  %xmm1,0x40(%rsp)
call   1040 <sqrt@plt>
movsd  0x40(%rsp),%xmm1
movsd  0x8(%rsp),%xmm4
movsd  0x20(%rsp),%xmm9
xorpd  %xmm8,%xmm8
xorpd  %xmm2,%xmm2
cmpnlesd %xmm1,%xmm2
movapd %xmm2,%xmm3
andpd  %xmm0,%xmm3
xorpd  0xbf8(%rip),%xmm0
andnpd %xmm0,%xmm2
orpd   %xmm3,%xmm2
mulsd  %xmm2,%xmm4
movsd  %xmm4,(%r15,%rbx,8)
movapd %xmm1,%xmm0
mulsd  %xmm2,%xmm0
subsd  %xmm0,%xmm9
subsd  %xmm2,%xmm1
mov    (%r14,%rbx,8),%rax
movsd  %xmm1,-0x10(%rax,%rbp,8)
lea    0x8(%rax),%r10
mov    $0x1,%r9d
movabs $0x200000000,%r8
mov    0x48(%rsp),%r11
mov    %r10,%r13
xor    %esi,%esi
jmp    1492 <make_symmetric_matrix_triangular+0x372>
cs nopw 0x0(%rax,%rax,1)
nop
divsd  %xmm9,%xmm0
movsd  %xmm0,(%r15,%rsi,8)
mulsd  (%rax,%rsi,8),%xmm0
addsd  %xmm0,%xmm8
add    $0x1,%r9
add    $0x8,%r13
add    $0x8,%r11
add    %r12,%r8
mov    %rdx,%rsi
cmp    0x10(%rsp),%rdx
je     1590 <make_symmetric_matrix_triangular+0x470>
movsd  (%rax,%rsi,8),%xmm0
divsd  %xmm9,%xmm0
mov    (%r14,%rsi,8),%rdx
movsd  %xmm0,(%rdx,%rbx,8)
cmp    $0x3,%rsi
jae    14c0 <make_symmetric_matrix_triangular+0x3a0>
xor    %ebp,%ebp
xorpd  %xmm0,%xmm0
jmp    1517 <make_symmetric_matrix_triangular+0x3f7>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r9,%rdi
and    $0xfffffffffffffffc,%rdi
xorpd  %xmm0,%xmm0
xor    %ebp,%ebp
nopl   (%rax)
movsd  (%rdx,%rbp,8),%xmm2
movsd  0x8(%rdx,%rbp,8),%xmm3
mulsd  (%rax,%rbp,8),%xmm2
mulsd  0x8(%rax,%rbp,8),%xmm3
addsd  %xmm0,%xmm2
movsd  0x10(%rdx,%rbp,8),%xmm4
mulsd  0x10(%rax,%rbp,8),%xmm4
addsd  %xmm2,%xmm3
movsd  0x18(%rdx,%rbp,8),%xmm0
mulsd  0x18(%rax,%rbp,8),%xmm0
addsd  %xmm3,%xmm4
addsd  %xmm4,%xmm0
add    $0x4,%rbp
cmp    %rbp,%rdi
jne    14d0 <make_symmetric_matrix_triangular+0x3b0>
test   $0x3,%r9b
je     1547 <make_symmetric_matrix_triangular+0x427>
mov    %r9d,%edi
and    $0x3,%edi
lea    (%rax,%rbp,8),%rcx
lea    (%rdx,%rbp,8),%rdx
xor    %ebp,%ebp
nopl   (%rax)
movsd  (%rdx,%rbp,8),%xmm2
mulsd  (%rcx,%rbp,8),%xmm2
addsd  %xmm2,%xmm0
add    $0x1,%rbp
cmp    %rbp,%rdi
jne    1530 <make_symmetric_matrix_triangular+0x410>
lea    0x1(%rsi),%rdx
cmp    %rbx,%rdx
jge    1460 <make_symmetric_matrix_triangular+0x340>
mov    %r8,%rdi
xor    %ebp,%ebp
nopl   0x0(%rax)
mov    (%r11,%rbp,1),%rcx
movsd  (%rcx,%rsi,8),%xmm2
mulsd  0x0(%r13,%rbp,1),%xmm2
addsd  %xmm2,%xmm0
mov    %rdi,%rcx
sar    $0x20,%rcx
add    $0x8,%rbp
add    %r12,%rdi
cmp    %rbx,%rcx
jl     1560 <make_symmetric_matrix_triangular+0x440>
jmp    1460 <make_symmetric_matrix_triangular+0x340>
nopl   0x0(%rax)
movapd %xmm9,%xmm0
addsd  %xmm9,%xmm0
xorpd  0xa5d(%rip),%xmm8
divsd  %xmm0,%xmm8
mov    $0x1,%edx
xor    %r8d,%r8d
jmp    15cf <make_symmetric_matrix_triangular+0x4af>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rdx
cmp    0x10(%rsp),%r8
je     1770 <make_symmetric_matrix_triangular+0x650>
mov    %r8,%r9
movsd  (%rax,%r8,8),%xmm0
movapd %xmm8,%xmm2
mulsd  %xmm0,%xmm2
addsd  (%r15,%r8,8),%xmm2
add    $0x1,%r8
movsd  %xmm2,(%r15,%r9,8)
mov    (%r14,%r9,8),%rsi
cmp    $0x3,%r9
jb     16d0 <make_symmetric_matrix_triangular+0x5b0>
lea    (%rax,%r8,8),%rcx
lea    (%r15,%r8,8),%rdi
lea    (%rsi,%r8,8),%rbp
cmp    %rdi,%rsi
setb   %r11b
cmp    %r15,%rbp
seta   %r13b
cmp    %rcx,%rsi
setb   %cl
cmp    %rbp,%rax
setb   %dil
test   %r13b,%r11b
jne    16d0 <make_symmetric_matrix_triangular+0x5b0>
mov    $0x0,%ebp
and    %dil,%cl
jne    16d2 <make_symmetric_matrix_triangular+0x5b2>
mov    %rdx,%rcx
and    $0xfffffffffffffffc,%rcx
mov    %r8,%rbp
and    $0xfffffffffffffffc,%rbp
movapd %xmm2,%xmm3
unpcklpd %xmm2,%xmm3
movapd %xmm0,%xmm4
unpcklpd %xmm0,%xmm4
xor    %edi,%edi
nopl   (%rax)
movupd (%r15,%rdi,8),%xmm5
movupd 0x10(%r15,%rdi,8),%xmm6
movupd (%rax,%rdi,8),%xmm7
movupd 0x10(%rax,%rdi,8),%xmm1
mulpd  %xmm3,%xmm7
mulpd  %xmm3,%xmm1
mulpd  %xmm4,%xmm5
addpd  %xmm7,%xmm5
mulpd  %xmm4,%xmm6
addpd  %xmm1,%xmm6
movupd (%rsi,%rdi,8),%xmm1
subpd  %xmm5,%xmm1
movupd 0x10(%rsi,%rdi,8),%xmm5
subpd  %xmm6,%xmm5
movupd %xmm1,(%rsi,%rdi,8)
movupd %xmm5,0x10(%rsi,%rdi,8)
add    $0x4,%rdi
cmp    %rdi,%rcx
jne    1660 <make_symmetric_matrix_triangular+0x540>
cmp    %rbp,%r8
je     15c0 <make_symmetric_matrix_triangular+0x4a0>
jmp    16d2 <make_symmetric_matrix_triangular+0x5b2>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xor    %ebp,%ebp
mov    %rbp,%rcx
test   $0x1,%dl
je     1706 <make_symmetric_matrix_triangular+0x5e6>
movsd  (%rax,%rbp,8),%xmm1
mulsd  %xmm2,%xmm1
movsd  (%r15,%rbp,8),%xmm3
mulsd  %xmm0,%xmm3
addsd  %xmm1,%xmm3
movsd  (%rsi,%rbp,8),%xmm1
subsd  %xmm3,%xmm1
movsd  %xmm1,(%rsi,%rbp,8)
mov    %rbp,%rcx
or     $0x1,%rcx
cmp    %rbp,%r9
je     15c0 <make_symmetric_matrix_triangular+0x4a0>
nop
movsd  -0x8(%r10,%rcx,8),%xmm1
mulsd  %xmm2,%xmm1
movsd  (%r15,%rcx,8),%xmm3
mulsd  %xmm0,%xmm3
addsd  %xmm1,%xmm3
movsd  (%rsi,%rcx,8),%xmm1
subsd  %xmm3,%xmm1
movsd  0x8(%rsi,%rcx,8),%xmm3
movsd  %xmm1,(%rsi,%rcx,8)
movsd  (%r10,%rcx,8),%xmm1
mulsd  %xmm2,%xmm1
movsd  0x8(%r15,%rcx,8),%xmm4
mulsd  %xmm0,%xmm4
addsd  %xmm1,%xmm4
subsd  %xmm4,%xmm3
movsd  %xmm3,0x8(%rsi,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rdx
jne    1710 <make_symmetric_matrix_triangular+0x5f0>
jmp    15c0 <make_symmetric_matrix_triangular+0x4a0>
xchg   %ax,%ax
mov    0x28(%rsp),%rcx
jmp    11a6 <make_symmetric_matrix_triangular+0x86>
mov    0x8(%r14),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,0x8(%r15)
mov    0x18(%rsp),%rax
movq   $0x0,(%rax,%rbx,8)
movq   $0x0,(%r15)
mov    0x18(%rsp),%rax
movq   $0x0,(%rax)
cmpl   $0x0,0x30(%rsp)
jle    19f7 <make_symmetric_matrix_triangular+0x8d7>
xorpd  %xmm0,%xmm0
xor    %ebp,%ebp
nopl   0x0(%rax)
mov    %ebp,%r15d
and    $0x3,%r15d
mov    %rbp,%r12
and    $0xfffffffffffffffc,%r12
mov    %rbp,%r13
add    $0xffffffffffffffff,%r13
setb   %bl
call   1030 <fabs@plt>
mov    (%r14,%rbp,8),%rcx
test   %rax,%rax
jle    1920 <make_symmetric_matrix_triangular+0x800>
test   %bl,%bl
je     1920 <make_symmetric_matrix_triangular+0x800>
mov    %rbp,%r8
and    $0xfffffffffffffffe,%r8
xor    %edx,%edx
jmp    180d <make_symmetric_matrix_triangular+0x6ed>
nopl   (%rax)
add    $0x1,%rdx
cmp    %rbp,%rdx
je     1920 <make_symmetric_matrix_triangular+0x800>
xorpd  %xmm0,%xmm0
xor    %esi,%esi
cmp    $0x3,%r13
jb     1877 <make_symmetric_matrix_triangular+0x757>
nopl   0x0(%rax)
movsd  (%rcx,%rsi,8),%xmm1
movsd  0x8(%rcx,%rsi,8),%xmm2
mov    (%r14,%rsi,8),%rax
mov    0x8(%r14,%rsi,8),%rdi
mulsd  (%rax,%rdx,8),%xmm1
addsd  %xmm0,%xmm1
mulsd  (%rdi,%rdx,8),%xmm2
addsd  %xmm1,%xmm2
movsd  0x10(%rcx,%rsi,8),%xmm1
mov    0x10(%r14,%rsi,8),%rax
mulsd  (%rax,%rdx,8),%xmm1
movsd  0x18(%rcx,%rsi,8),%xmm0
mov    0x18(%r14,%rsi,8),%rax
mulsd  (%rax,%rdx,8),%xmm0
addsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
add    $0x4,%rsi
cmp    %rsi,%r12
jne    1820 <make_symmetric_matrix_triangular+0x700>
test   $0x3,%bpl
je     18ab <make_symmetric_matrix_triangular+0x78b>
lea    (%r14,%rsi,8),%rdi
lea    (%rcx,%rsi,8),%rsi
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movsd  (%rsi,%rax,8),%xmm1
mov    (%rdi,%rax,8),%rbx
mulsd  (%rbx,%rdx,8),%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rax
cmp    %rax,%r15
jne    1890 <make_symmetric_matrix_triangular+0x770>
xorpd  0x74d(%rip),%xmm0
xor    %esi,%esi
cmp    $0x1,%rbp
je     18f8 <make_symmetric_matrix_triangular+0x7d8>
nopl   0x0(%rax,%rax,1)
mov    (%r14,%rsi,8),%rax
movsd  (%rax,%rbp,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rax,%rdx,8),%xmm1
movsd  %xmm1,(%rax,%rdx,8)
mov    0x8(%r14,%rsi,8),%rax
movsd  (%rax,%rbp,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rax,%rdx,8),%xmm1
movsd  %xmm1,(%rax,%rdx,8)
add    $0x2,%rsi
cmp    %rsi,%r8
jne    18c0 <make_symmetric_matrix_triangular+0x7a0>
test   $0x1,%bpl
je     1800 <make_symmetric_matrix_triangular+0x6e0>
mov    (%r14,%rsi,8),%rax
mulsd  (%rax,%rbp,8),%xmm0
addsd  (%rax,%rdx,8),%xmm0
movsd  %xmm0,(%rax,%rdx,8)
jmp    1800 <make_symmetric_matrix_triangular+0x6e0>
nopw   0x0(%rax,%rax,1)
movsd  (%rcx,%rbp,8),%xmm0
mov    0x18(%rsp),%rax
movsd  %xmm0,(%rax,%rbp,8)
movabs $0x3ff0000000000000,%rax
mov    %rax,(%rcx,%rbp,8)
test   %rbp,%rbp
je     19dd <make_symmetric_matrix_triangular+0x8bd>
xor    %eax,%eax
cmp    $0x3,%r13
jb     19af <make_symmetric_matrix_triangular+0x88f>
xchg   %ax,%ax
movq   $0x0,(%rcx,%rax,8)
mov    (%r14,%rax,8),%rdx
movq   $0x0,(%rdx,%rbp,8)
movq   $0x0,0x8(%rcx,%rax,8)
mov    0x8(%r14,%rax,8),%rdx
movq   $0x0,(%rdx,%rbp,8)
movq   $0x0,0x10(%rcx,%rax,8)
mov    0x10(%r14,%rax,8),%rdx
movq   $0x0,(%rdx,%rbp,8)
movq   $0x0,0x18(%rcx,%rax,8)
mov    0x18(%r14,%rax,8),%rdx
movq   $0x0,(%rdx,%rbp,8)
add    $0x4,%rax
cmp    %rax,%r12
jne    1950 <make_symmetric_matrix_triangular+0x830>
test   $0x3,%bpl
je     19dd <make_symmetric_matrix_triangular+0x8bd>
lea    (%r14,%rax,8),%rdx
lea    (%rcx,%rax,8),%rax
xor    %ecx,%ecx
nop
movq   $0x0,(%rax,%rcx,8)
mov    (%rdx,%rcx,8),%rsi
movq   $0x0,(%rsi,%rbp,8)
add    $0x1,%rcx
cmp    %rcx,%r15
jne    19c0 <make_symmetric_matrix_triangular+0x8a0>
add    $0x1,%rbp
cmp    0x38(%rsp),%rbp
je     19f7 <make_symmetric_matrix_triangular+0x8d7>
mov    0x18(%rsp),%rax
movsd  (%rax,%rbp,8),%xmm0
jmp    17c0 <make_symmetric_matrix_triangular+0x6a0>
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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