void Tred2(int n, double **a, double *d, double *e, double **z) {
  int i, j, k, l;
  double f, g, h, hh, scale;
  for (i = 0; i < n; i++) {
    for (j = i; j < n; j++)
      z[j][i] = a[j][i];
    d[i] = a[n - 1][i];
  }
  for (i = n - 1; i > 0; i--) {
    l = i - 1;
    h = scale = 0.0;
    if (l > 0) {
      for (k = 0; k < i; k++)
        scale += fabs(d[k]);
    }
    if (scale == 0.0) {
      e[i] = d[l];
      for (j = 0; j < i; j++) {
        d[j] = z[l][j];
        z[i][j] = z[j][i] = 0.0;
      }
    } else {
      for (k = 0; k < i; k++) {
        d[k] = d[k] / scale;
        h += d[k] * d[k];
      }
      f = d[l];
      g = -Sign(sqrt(h), f);
      e[i] = scale * g;
      h -= f * g;
      d[l] = f - g;
      for (j = 0; j < i; j++)
        e[j] = 0.0;
      for (j = 0; j < i; j++) {
        f = d[j];
        z[j][i] = f;
        g = e[j] + z[j][j] * f;
        if (l > j) {
          for (k = j + 1; k < i; k++) {
            g += z[k][j] * d[k];
            e[k] += z[k][j] * f;
          }
        }
        e[j] = g;
      }
      f = 0.0;
      for (j = 0; j < i; j++) {
        e[j] /= h;
        f += e[j] * d[j];
      }
      hh = f / (h + h);
      for (j = 0; j < i; j++)
        e[j] -= hh * d[j];
      for (j = 0; j < i; j++) {
        f = d[j];
        g = e[j];
        for (k = j; k < i; k++)
          z[k][j] -= (f * e[k] + g * d[k]);
        d[j] = z[l][j];
        z[i][j] = 0.0;
      }
    }
    d[i] = h;
  }
  for (i = 1; i < n; i++) {
    l = i - 1;
    z[n - 1][l] = z[l][l];
    z[l][l] = 1.0;
    h = d[i];
    if (h != 0.0) {
      for (k = 0; k <= l; k++)
        d[k] = z[k][i] / h;
      for (j = 0; j <= l; j++) {
        g = 0.0;
        for (k = 0; k <= l; k++)
          g += z[k][i] * z[k][j];
        for (k = 0; k <= l; k++)
          z[k][j] -= g * d[k];
      }
    }
    for (k = 0; k <= l; k++)
      z[k][i] = 0.0;
  }
  for (i = 0; i < n; i++) {
    d[i] = z[n - 1][i];
    z[n - 1][i] = 0.0;
  }
  z[n - 1][n - 1] = 1.0;
  e[0] = 0.0;
}


x86 assembly (clang, -O0):
<Tred2>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    11cd <Tred2+0xad>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1198 <Tred2+0x78>
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1154 <Tred2+0x34>
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1142 <Tred2+0x22>
mov    -0x4(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x2c(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jle    1753 <Tred2+0x633>
mov    -0x2c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x38(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
cmpl   $0x0,-0x38(%rbp)
jle    124b <Tred2+0x12b>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1246 <Tred2+0x126>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xde6(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    120a <Tred2+0xea>
jmp    124b <Tred2+0x12b>
movsd  -0x60(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    12f5 <Tred2+0x1d5>
jp     12f5 <Tred2+0x1d5>
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    12f0 <Tred2+0x1d0>
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1284 <Tred2+0x164>
jmp    1733 <Tred2+0x613>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1361 <Tred2+0x241>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x60(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12fc <Tred2+0x1dc>
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x50(%rbp),%xmm0
call   1040 <sqrt@plt>
movsd  -0x40(%rbp),%xmm1
mov    $0x2,%al
call   1030 <Sign@plt>
mov    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x60(%rbp),%xmm0
mulsd  -0x48(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x40(%rbp),%xmm0
movsd  -0x48(%rbp),%xmm2
movsd  -0x50(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x40(%rbp),%xmm0
subsd  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    142a <Tred2+0x30a>
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1400 <Tred2+0x2e0>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1559 <Tred2+0x439>
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x40(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x40(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x30(%rbp),%eax
jle    1539 <Tred2+0x419>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1534 <Tred2+0x414>
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x48(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x40(%rbp),%xmm2
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    14b2 <Tred2+0x392>
jmp    1539 <Tred2+0x419>
movsd  -0x48(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1431 <Tred2+0x311>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    15c9 <Tred2+0x4a9>
movsd  -0x50(%rbp),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x40(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1568 <Tred2+0x448>
movsd  -0x40(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm1
addsd  -0x50(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1645 <Tred2+0x525>
movsd  -0x58(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rax
movslq -0x30(%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    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    15e8 <Tred2+0x4c8>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    172e <Tred2+0x60e>
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    16e6 <Tred2+0x5c6>
movsd  -0x40(%rbp),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1682 <Tred2+0x562>
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    164c <Tred2+0x52c>
jmp    1733 <Tred2+0x613>
movsd  -0x50(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    11d6 <Tred2+0xb6>
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    197a <Tred2+0x85a>
mov    -0x2c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  0x84a(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    17ea <Tred2+0x6ca>
jp     17ea <Tred2+0x6ca>
jmp    192e <Tred2+0x80e>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x38(%rbp),%eax
jg     1832 <Tred2+0x712>
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x50(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    17f1 <Tred2+0x6d1>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x38(%rbp),%eax
jg     1929 <Tred2+0x809>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x38(%rbp),%eax
jg     18aa <Tred2+0x78a>
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x48(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1854 <Tred2+0x734>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x38(%rbp),%eax
jg     1916 <Tred2+0x7f6>
movsd  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%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    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    18b1 <Tred2+0x791>
jmp    191b <Tred2+0x7fb>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1839 <Tred2+0x719>
jmp    192e <Tred2+0x80e>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x38(%rbp),%eax
jg     1967 <Tred2+0x847>
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1935 <Tred2+0x815>
jmp    196c <Tred2+0x84c>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    175a <Tred2+0x63a>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    19df <Tred2+0x8bf>
mov    -0x28(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1981 <Tred2+0x861>
mov    -0x28(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  0x5ff(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Tred2>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xc8,%rsp
mov    %r8,%r13
mov    %rcx,%r14
lea    -0x1(%rdi),%ecx
movabs $0x3ff0000000000000,%r12
test   %edi,%edi
jle    1d10 <Tred2+0xbe0>
mov    %rdx,%r15
mov    %ecx,0x54(%rsp)
mov    %ecx,%eax
mov    %rax,0x58(%rsp)
mov    (%rsi,%rax,8),%r9
mov    %edi,%r11d
mov    %rdi,0x28(%rsp)
cmp    $0x1,%edi
mov    %r11,0x8(%rsp)
jne    1188 <Tred2+0x58>
xor    %r10d,%r10d
jmp    1231 <Tred2+0x101>
mov    %r11d,%r8d
and    $0xfffffffe,%r8d
xor    %r10d,%r10d
mov    %rsi,%rbp
mov    %r13,%rdx
nopl   0x0(%rax,%rax,1)
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x0(%rbp,%rax,8),%rcx
movsd  (%rcx,%r10,8),%xmm0
mov    (%rdx,%rax,8),%rcx
movsd  %xmm0,(%rcx,%r10,8)
add    $0x1,%rax
cmp    %rax,%r11
jne    11b0 <Tred2+0x80>
movsd  (%r9,%r10,8),%xmm0
movsd  %xmm0,(%r15,%r10,8)
mov    %r10,%rcx
or     $0x1,%rcx
mov    $0x1,%eax
cs nopw 0x0(%rax,%rax,1)
mov    0x0(%rbp,%rax,8),%rdi
movsd  (%rdi,%rcx,8),%xmm0
mov    (%rdx,%rax,8),%rdi
movsd  %xmm0,(%rdi,%rcx,8)
add    $0x1,%rax
cmp    %rax,%r11
jne    11f0 <Tred2+0xc0>
movsd  (%r9,%rcx,8),%xmm0
movsd  %xmm0,(%r15,%rcx,8)
add    $0x2,%r10
add    $0x10,%rdx
add    $0x10,%rbp
add    $0xfffffffffffffffe,%r11
cmp    %r8,%r10
jne    11a0 <Tred2+0x70>
mov    0x8(%rsp),%rdx
test   $0x1,%dl
mov    0x58(%rsp),%r11
je     127a <Tred2+0x14a>
mov    %r10,%rax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%rsi,%rax,8),%rcx
movsd  (%rcx,%r10,8),%xmm0
mov    0x0(%r13,%rax,8),%rcx
movsd  %xmm0,(%rcx,%r10,8)
add    $0x1,%rax
cmp    %rax,%rdx
jne    1250 <Tred2+0x120>
movsd  (%r9,%r10,8),%xmm0
movsd  %xmm0,(%r15,%r10,8)
cmpl   $0x2,0x28(%rsp)
jl     1cea <Tred2+0xbba>
movabs $0x100000000,%rbx
lea    0x0(,%r11,8),%rax
mov    %rax,0x78(%rsp)
mov    0x8(%rsp),%rax
lea    -0x1(%rax),%rcx
mov    %rcx,(%rsp)
lea    -0x2(%rax),%rcx
mov    %rcx,0x20(%rsp)
lea    0x8(%r14),%rcx
mov    %rcx,0x40(%rsp)
lea    0x8(%r15),%rbp
lea    0x8(%r13),%r9
lea    -0x5(%rax),%r10
xor    %edi,%edi
xorpd  %xmm8,%xmm8
movapd 0xd39(%rip),%xmm9
movapd 0xd20(%rip),%xmm10
movapd 0xd18(%rip),%xmm7
mov    %rbp,0x38(%rsp)
mov    %r9,0x30(%rsp)
jmp    131a <Tred2+0x1ea>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r8,%r11
movsd  %xmm11,(%r15,%r12,8)
add    $0x1,%rdi
add    $0xffffffffffffffff,%r10
cmp    %r8,%rdi
je     1a5c <Tred2+0x92c>
mov    (%rsp),%r12
mov    %r12,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,0x48(%rsp)
lea    -0x1(%r12),%rax
mov    %rax,(%rsp)
cmp    $0x1,%r12
je     13f8 <Tred2+0x2c8>
mov    %r12,%rsi
and    $0xfffffffffffffffc,%rsi
mov    0x20(%rsp),%rax
sub    %rdi,%rax
cmp    $0x3,%rax
jae    1360 <Tred2+0x230>
xorpd  %xmm4,%xmm4
xor    %eax,%eax
jmp    13b8 <Tred2+0x288>
nopw   0x0(%rax,%rax,1)
xorpd  %xmm0,%xmm0
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
movsd  (%r15,%rax,8),%xmm1
movsd  0x8(%r15,%rax,8),%xmm2
movsd  0x10(%r15,%rax,8),%xmm3
movsd  0x18(%r15,%rax,8),%xmm4
andpd  %xmm7,%xmm1
addsd  %xmm0,%xmm1
andpd  %xmm7,%xmm2
addsd  %xmm1,%xmm2
andpd  %xmm7,%xmm3
addsd  %xmm2,%xmm3
andpd  %xmm7,%xmm4
addsd  %xmm3,%xmm4
add    $0x4,%rax
movapd %xmm4,%xmm0
cmp    %rax,%rsi
jne    1370 <Tred2+0x240>
test   $0x3,%r12b
je     13e7 <Tred2+0x2b7>
mov    %r12d,%ecx
and    $0x3,%ecx
lea    (%r15,%rax,8),%rax
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movsd  (%rax,%rdx,8),%xmm0
andpd  %xmm10,%xmm0
addsd  %xmm0,%xmm4
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    13d0 <Tred2+0x2a0>
ucomisd %xmm8,%xmm4
jne    14ae <Tred2+0x37e>
jp     14ae <Tred2+0x37e>
mov    %r11,%r8
mov    (%rsp),%rax
movsd  (%r15,%rax,8),%xmm0
movsd  %xmm0,(%r14,%r12,8)
mov    0x0(%r13,%rax,8),%rcx
mov    0x0(%r13,%r12,8),%rax
cmp    %rdi,0x20(%rsp)
jne    1420 <Tred2+0x2f0>
xor    %edx,%edx
jmp    147a <Tred2+0x34a>
xor    %edx,%edx
mov    0x48(%rsp),%r11
nopw   0x0(%rax,%rax,1)
movsd  (%rcx,%rdx,8),%xmm0
movsd  %xmm0,-0x8(%rbp,%rdx,8)
mov    -0x8(%r9,%rdx,8),%rsi
movq   $0x0,(%rsi,%r12,8)
movq   $0x0,(%rax,%rdx,8)
movsd  0x8(%rcx,%rdx,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rdx,8)
mov    (%r9,%rdx,8),%rsi
movq   $0x0,(%rsi,%r12,8)
movq   $0x0,0x8(%rax,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%r11
jne    1430 <Tred2+0x300>
xorpd  %xmm11,%xmm11
test   $0x1,%r12b
je     1300 <Tred2+0x1d0>
movsd  (%rcx,%rdx,8),%xmm0
movsd  %xmm0,(%r15,%rdx,8)
mov    0x0(%r13,%rdx,8),%rcx
movq   $0x0,(%rcx,%r12,8)
movq   $0x0,(%rax,%rdx,8)
jmp    1300 <Tred2+0x1d0>
cmp    %rdi,0x20(%rsp)
jne    14bd <Tred2+0x38d>
xorpd  %xmm2,%xmm2
xor    %eax,%eax
jmp    150f <Tred2+0x3df>
xorpd  %xmm0,%xmm0
xor    %eax,%eax
mov    0x48(%rsp),%rcx
nopl   0x0(%rax,%rax,1)
movsd  (%r15,%rax,8),%xmm1
movsd  0x8(%r15,%rax,8),%xmm2
divsd  %xmm4,%xmm1
movsd  %xmm1,(%r15,%rax,8)
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
divsd  %xmm4,%xmm2
movsd  %xmm2,0x8(%r15,%rax,8)
mulsd  %xmm2,%xmm2
addsd  %xmm1,%xmm2
add    $0x2,%rax
movapd %xmm2,%xmm0
cmp    %rax,%rcx
jne    14d0 <Tred2+0x3a0>
mov    %r10,%rdx
shr    $0x2,%rdx
lea    -0x4(%r12),%rbp
lea    0x0(,%rdi,8),%r8
test   $0x1,%r12b
je     1541 <Tred2+0x411>
movsd  (%r15,%rax,8),%xmm0
divsd  %xmm4,%xmm0
movsd  %xmm0,(%r15,%rax,8)
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm2
add    $0x1,%rdx
mov    %rdx,0x18(%rsp)
mov    %rbp,%rdx
shr    $0x2,%rdx
mov    0x78(%rsp),%rcx
sub    %r8,%rcx
mov    (%rsp),%rax
movsd  (%r15,%rax,8),%xmm1
ucomisd %xmm8,%xmm2
mov    %r10,0x68(%rsp)
mov    %rdi,0xa8(%rsp)
mov    %rsi,0x60(%rsp)
mov    %rbp,0x80(%rsp)
movapd %xmm4,0xb0(%rsp)
mov    %rcx,0xa0(%rsp)
movsd  %xmm1,0x70(%rsp)
movsd  %xmm2,0x10(%rsp)
jb     15aa <Tred2+0x47a>
xorps  %xmm0,%xmm0
sqrtsd %xmm2,%xmm0
jmp    15bf <Tred2+0x48f>
movapd %xmm2,%xmm0
mov    %rdx,%rbp
call   1050 <sqrt@plt>
movsd  0x70(%rsp),%xmm1
mov    %rbp,%rdx
mov    0x18(%rsp),%rbp
and    $0xfffffffffffffffe,%rbp
mov    %rbp,0x18(%rsp)
add    $0x1,%rdx
mov    %rdx,0x88(%rsp)
lea    (%r14,%r12,8),%rax
mov    %rax,0x90(%rsp)
lea    (%r15,%r12,8),%rax
mov    %rax,0x98(%rsp)
mov    $0x2,%al
call   1040 <Sign@plt>
neg    %eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movapd 0xb0(%rsp),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r14,%r12,8)
movsd  0x70(%rsp),%xmm3
movapd %xmm3,%xmm1
mulsd  %xmm0,%xmm1
movsd  0x10(%rsp),%xmm2
subsd  %xmm1,%xmm2
movsd  %xmm2,0x10(%rsp)
subsd  %xmm0,%xmm3
mov    (%rsp),%rax
movsd  %xmm3,(%r15,%rax,8)
mov    %r14,%rdi
xor    %esi,%esi
mov    0xa0(%rsp),%rdx
call   1030 <memset@plt>
movabs $0x200000000,%r9
mov    0x30(%rsp),%r10
mov    0x38(%rsp),%rdx
mov    0x40(%rsp),%rsi
xor    %r8d,%r8d
mov    0x58(%rsp),%r11
movapd 0x994(%rip),%xmm9
xorpd  %xmm8,%xmm8
movapd 0x976(%rip),%xmm10
movapd 0x96e(%rip),%xmm7
jmp    16be <Tred2+0x58e>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  %xmm0,(%r14,%rdi,8)
add    $0x8,%rsi
add    $0x8,%rdx
add    $0x8,%r10
add    %rbx,%r9
cmp    %r12,%r8
je     1742 <Tred2+0x612>
mov    %r8,%rdi
movsd  (%r15,%r8,8),%xmm1
mov    0x0(%r13,%r8,8),%rax
movsd  %xmm1,(%rax,%r12,8)
movsd  (%rax,%r8,8),%xmm0
mulsd  %xmm1,%xmm0
addsd  (%r14,%r8,8),%xmm0
add    $0x1,%r8
cmp    %rdi,(%rsp)
jle    16a0 <Tred2+0x570>
cmp    %r12,%r8
jge    16a0 <Tred2+0x570>
mov    %r9,%rcx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
mov    %rbx,%rax
mov    (%r10,%rbp,1),%rbx
movsd  (%rbx,%rdi,8),%xmm2
mov    %rax,%rbx
movsd  (%rdx,%rbp,1),%xmm3
mulsd  %xmm2,%xmm3
addsd  %xmm3,%xmm0
mulsd  %xmm1,%xmm2
addsd  (%rsi,%rbp,1),%xmm2
movsd  %xmm2,(%rsi,%rbp,1)
mov    %rcx,%rax
sar    $0x20,%rax
add    $0x8,%rbp
add    %rbx,%rcx
cmp    %r12,%rax
jl     1700 <Tred2+0x5d0>
jmp    16a0 <Tred2+0x570>
mov    0x20(%rsp),%r8
mov    0xa8(%rsp),%rdx
cmp    %rdx,%r8
jne    177c <Tred2+0x64c>
xorpd  %xmm0,%xmm0
xor    %eax,%eax
mov    0x40(%rsp),%rcx
mov    0x38(%rsp),%rbp
mov    0x30(%rsp),%r9
mov    0x68(%rsp),%r10
mov    0x60(%rsp),%rsi
movsd  0x10(%rsp),%xmm11
jmp    17f1 <Tred2+0x6c1>
xorpd  %xmm1,%xmm1
xor    %eax,%eax
mov    0x40(%rsp),%rcx
mov    0x38(%rsp),%rbp
mov    0x30(%rsp),%r9
mov    0x68(%rsp),%r10
mov    0x60(%rsp),%rsi
movsd  0x10(%rsp),%xmm11
mov    0x48(%rsp),%rdi
nopw   0x0(%rax,%rax,1)
movsd  -0x8(%rcx,%rax,8),%xmm2
movsd  (%rcx,%rax,8),%xmm0
divsd  %xmm11,%xmm2
movsd  %xmm2,-0x8(%rcx,%rax,8)
mulsd  -0x8(%rbp,%rax,8),%xmm2
divsd  %xmm11,%xmm0
movsd  %xmm0,(%rcx,%rax,8)
mulsd  0x0(%rbp,%rax,8),%xmm0
addsd  %xmm1,%xmm2
addsd  %xmm2,%xmm0
add    $0x2,%rax
movapd %xmm0,%xmm1
cmp    %rax,%rdi
jne    17b0 <Tred2+0x680>
test   $0x1,%r12b
je     1812 <Tred2+0x6e2>
movsd  (%r14,%rax,8),%xmm1
divsd  %xmm11,%xmm1
movsd  %xmm1,(%r14,%rax,8)
mulsd  (%r15,%rax,8),%xmm1
addsd  %xmm1,%xmm0
movapd %xmm11,%xmm1
addsd  %xmm11,%xmm1
xorpd  %xmm9,%xmm0
divsd  %xmm1,%xmm0
cmp    $0x4,%r12
mov    0x18(%rsp),%rdi
jb     1844 <Tred2+0x714>
cmp    %r14,0x98(%rsp)
jbe    18b8 <Tred2+0x788>
cmp    %r15,0x90(%rsp)
jbe    18b8 <Tred2+0x788>
xor    %esi,%esi
lea    (%rdx,%rsi,1),%rax
test   $0x1,%r12b
je     186a <Tred2+0x73a>
movsd  (%r15,%rsi,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%r14,%rsi,8),%xmm1
movsd  %xmm1,(%r14,%rsi,8)
or     $0x1,%rsi
cmp    %rax,%r8
je     19a5 <Tred2+0x875>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  -0x8(%rbp,%rsi,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  -0x8(%rcx,%rsi,8),%xmm1
movsd  %xmm1,-0x8(%rcx,%rsi,8)
movsd  0x0(%rbp,%rsi,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rcx,%rsi,8),%xmm1
movsd  %xmm1,(%rcx,%rsi,8)
add    $0x2,%rsi
cmp    %rsi,%r12
jne    1880 <Tred2+0x750>
jmp    19a5 <Tred2+0x875>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x4,0x80(%rsp)
jae    18d2 <Tred2+0x7a2>
xor    %eax,%eax
jmp    195b <Tred2+0x82b>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd (%r15,%rax,8),%xmm2
movupd 0x10(%r15,%rax,8),%xmm3
mulpd  %xmm1,%xmm2
movupd (%r14,%rax,8),%xmm4
addpd  %xmm2,%xmm4
movupd 0x10(%r14,%rax,8),%xmm2
movupd 0x20(%r14,%rax,8),%xmm5
movupd 0x30(%r14,%rax,8),%xmm6
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm4,(%r14,%rax,8)
movupd %xmm3,0x10(%r14,%rax,8)
movupd 0x20(%r15,%rax,8),%xmm2
movupd 0x30(%r15,%rax,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm5,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm6,%xmm3
movupd %xmm2,0x20(%r14,%rax,8)
movupd %xmm3,0x30(%r14,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rdi
jne    18e0 <Tred2+0x7b0>
testb  $0x1,0x88(%rsp)
01
je     199c <Tred2+0x86c>
movupd (%r15,%rax,8),%xmm2
movupd 0x10(%r15,%rax,8),%xmm3
movupd (%r14,%rax,8),%xmm4
movupd 0x10(%r14,%rax,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,(%r14,%rax,8)
movupd %xmm3,0x10(%r14,%rax,8)
cmp    %rsi,%r12
jne    1846 <Tred2+0x716>
mov    %r11,%r8
mov    %rdx,%r11
mov    (%rsp),%rax
mov    0x0(%r13,%rax,8),%rax
mov    0x0(%r13,%r12,8),%rcx
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movsd  (%r15,%rdx,8),%xmm0
movsd  (%r14,%rdx,8),%xmm1
movapd %xmm1,%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm2,%xmm2
mov    0x0(%r13,%rdx,8),%rsi
movsd  (%rsi,%rdx,8),%xmm3
subsd  %xmm2,%xmm3
movsd  %xmm3,(%rsi,%rdx,8)
lea    0x1(%rdx),%rsi
cmp    %r12,%rsi
jge    1a34 <Tred2+0x904>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%r15,%rsi,8),%xmm2
mulsd  %xmm1,%xmm2
movsd  (%r14,%rsi,8),%xmm3
mulsd  %xmm0,%xmm3
addsd  %xmm2,%xmm3
mov    0x0(%r13,%rsi,8),%rdi
movsd  (%rdi,%rdx,8),%xmm2
subsd  %xmm3,%xmm2
movsd  %xmm2,(%rdi,%rdx,8)
add    $0x1,%rsi
cmp    %r12,%rsi
jl     1a00 <Tred2+0x8d0>
movsd  (%rax,%rdx,8),%xmm0
movsd  %xmm0,(%r15,%rdx,8)
movq   $0x0,(%rcx,%rdx,8)
add    $0x1,%rdx
cmp    %r12,%rdx
jne    19c0 <Tred2+0x890>
mov    %r11,%rdi
jmp    1300 <Tred2+0x1d0>
cmpl   $0x2,0x28(%rsp)
movabs $0x3ff0000000000000,%r12
jl     1cea <Tred2+0xbba>
mov    0x0(%r13,%r11,8),%r8
mov    $0x1,%ecx
xor    %r9d,%r9d
xorpd  %xmm0,%xmm0
jmp    1aa3 <Tred2+0x973>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rcx
add    $0x1,%r9
cmp    0x8(%rsp),%rcx
je     1cea <Tred2+0xbba>
mov    %ecx,%esi
and    $0x3,%esi
mov    %rcx,%r10
and    $0xfffffffffffffffc,%r10
mov    -0x8(%r13,%rcx,8),%rax
movsd  -0x8(%rax,%rcx,8),%xmm1
movsd  %xmm1,-0x8(%r8,%rcx,8)
mov    %r12,-0x8(%rax,%rcx,8)
movsd  (%r15,%rcx,8),%xmm1
ucomisd %xmm0,%xmm1
jne    1ad8 <Tred2+0x9a8>
jnp    1c60 <Tred2+0xb30>
mov    %rcx,%rbp
and    $0xfffffffffffffffe,%rbp
xor    %eax,%eax
test   %r9,%r9
je     1b22 <Tred2+0x9f2>
cs nopw 0x0(%rax,%rax,1)
mov    0x0(%r13,%rax,8),%rdx
movsd  (%rdx,%rcx,8),%xmm2
divsd  %xmm1,%xmm2
movsd  %xmm2,(%r15,%rax,8)
mov    0x8(%r13,%rax,8),%rdx
movsd  (%rdx,%rcx,8),%xmm2
divsd  %xmm1,%xmm2
movsd  %xmm2,0x8(%r15,%rax,8)
add    $0x2,%rax
cmp    %rax,%rbp
jne    1af0 <Tred2+0x9c0>
test   $0x1,%cl
je     1b3b <Tred2+0xa0b>
mov    0x0(%r13,%rax,8),%rdx
movsd  (%rdx,%rcx,8),%xmm2
divsd  %xmm1,%xmm2
movsd  %xmm2,(%r15,%rax,8)
xor    %eax,%eax
jmp    1b4d <Tred2+0xa1d>
nop
add    $0x1,%rax
cmp    %rcx,%rax
je     1c60 <Tred2+0xb30>
xorpd  %xmm1,%xmm1
xor    %edx,%edx
cmp    $0x3,%r9
jb     1bb5 <Tred2+0xa85>
nopl   0x0(%rax)
mov    0x0(%r13,%rdx,8),%rdi
mov    0x8(%r13,%rdx,8),%rbx
movsd  (%rdi,%rcx,8),%xmm2
mulsd  (%rdi,%rax,8),%xmm2
addsd  %xmm1,%xmm2
movsd  (%rbx,%rcx,8),%xmm3
mulsd  (%rbx,%rax,8),%xmm3
addsd  %xmm2,%xmm3
mov    0x10(%r13,%rdx,8),%rdi
movsd  (%rdi,%rcx,8),%xmm2
mulsd  (%rdi,%rax,8),%xmm2
mov    0x18(%r13,%rdx,8),%rdi
movsd  (%rdi,%rcx,8),%xmm1
mulsd  (%rdi,%rax,8),%xmm1
addsd  %xmm3,%xmm2
addsd  %xmm2,%xmm1
add    $0x4,%rdx
cmp    %rdx,%r10
jne    1b60 <Tred2+0xa30>
test   $0x3,%cl
je     1beb <Tred2+0xabb>
lea    0x0(,%rdx,8),%rdx
add    %r13,%rdx
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
mov    (%rdx,%rdi,8),%rbx
movsd  (%rbx,%rcx,8),%xmm2
mulsd  (%rbx,%rax,8),%xmm2
addsd  %xmm2,%xmm1
add    $0x1,%rdi
cmp    %rdi,%rsi
jne    1bd0 <Tred2+0xaa0>
xorpd  %xmm9,%xmm1
xor    %edx,%edx
test   %r9,%r9
je     1c3c <Tred2+0xb0c>
nopw   0x0(%rax,%rax,1)
mov    0x0(%r13,%rdx,8),%rdi
movsd  (%r15,%rdx,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rdi,%rax,8),%xmm2
movsd  %xmm2,(%rdi,%rax,8)
mov    0x8(%r13,%rdx,8),%rdi
movsd  0x8(%r15,%rdx,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rdi,%rax,8),%xmm2
movsd  %xmm2,(%rdi,%rax,8)
add    $0x2,%rdx
cmp    %rdx,%rbp
jne    1c00 <Tred2+0xad0>
test   $0x1,%cl
je     1b40 <Tred2+0xa10>
mulsd  (%r15,%rdx,8),%xmm1
mov    0x0(%r13,%rdx,8),%rdx
addsd  (%rdx,%rax,8),%xmm1
movsd  %xmm1,(%rdx,%rax,8)
jmp    1b40 <Tred2+0xa10>
nop
xor    %eax,%eax
cmp    $0x3,%r9
jb     1cad <Tred2+0xb7d>
nopl   0x0(%rax,%rax,1)
mov    0x0(%r13,%rax,8),%rdx
movq   $0x0,(%rdx,%rcx,8)
mov    0x8(%r13,%rax,8),%rdx
movq   $0x0,(%rdx,%rcx,8)
mov    0x10(%r13,%rax,8),%rdx
movq   $0x0,(%rdx,%rcx,8)
mov    0x18(%r13,%rax,8),%rdx
movq   $0x0,(%rdx,%rcx,8)
add    $0x4,%rax
cmp    %rax,%r10
jne    1c70 <Tred2+0xb40>
test   $0x3,%cl
je     1a90 <Tred2+0x960>
lea    0x0(,%rax,8),%rax
add    %r13,%rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%rax,%rdx,8),%rdi
movq   $0x0,(%rdi,%rcx,8)
add    $0x1,%rdx
cmp    %rdx,%rsi
jne    1cd0 <Tred2+0xba0>
jmp    1a90 <Tred2+0x960>
mov    0x28(%rsp),%rax
test   %eax,%eax
mov    0x54(%rsp),%ecx
jle    1d10 <Tred2+0xbe0>
mov    %rax,%rcx
mov    0x0(%r13,%r11,8),%rax
cmp    $0x4,%ecx
jae    1d1d <Tred2+0xbed>
xor    %ecx,%ecx
mov    0x8(%rsp),%rbp
jmp    1df4 <Tred2+0xcc4>
movslq %ecx,%r11
mov    0x0(%r13,%r11,8),%rax
jmp    1e9e <Tred2+0xd6e>
mov    0x8(%rsp),%rbp
lea    (%rax,%rbp,8),%rcx
cmp    %r15,%rcx
jbe    1d3b <Tred2+0xc0b>
lea    (%r15,%rbp,8),%rcx
cmp    %rcx,%rax
jae    1d3b <Tred2+0xc0b>
xor    %ecx,%ecx
jmp    1df4 <Tred2+0xcc4>
mov    %ebp,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rsi
mov    %rsi,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rsi,%rsi
je     1ebb <Tred2+0xd8b>
mov    %rdx,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %esi,%esi
xorpd  %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
nop
movups (%rax,%rsi,8),%xmm1
movups 0x10(%rax,%rsi,8),%xmm2
movups %xmm1,(%r15,%rsi,8)
movups %xmm2,0x10(%r15,%rsi,8)
movupd %xmm0,(%rax,%rsi,8)
movupd %xmm0,0x10(%rax,%rsi,8)
movupd 0x20(%rax,%rsi,8),%xmm1
movupd 0x30(%rax,%rsi,8),%xmm2
movupd %xmm1,0x20(%r15,%rsi,8)
movupd %xmm2,0x30(%r15,%rsi,8)
movupd %xmm0,0x20(%rax,%rsi,8)
movupd %xmm0,0x30(%rax,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1d70 <Tred2+0xc40>
test   $0x1,%dl
je     1deb <Tred2+0xcbb>
movupd (%rax,%rsi,8),%xmm0
movupd 0x10(%rax,%rsi,8),%xmm1
movupd %xmm0,(%r15,%rsi,8)
movupd %xmm1,0x10(%r15,%rsi,8)
xorpd  %xmm0,%xmm0
movupd %xmm0,(%rax,%rsi,8)
movupd %xmm0,0x10(%rax,%rsi,8)
cmp    %rbp,%rcx
je     1e9e <Tred2+0xd6e>
mov    %rcx,%rdx
not    %rdx
add    %rbp,%rdx
mov    %rbp,%rsi
and    $0x3,%rsi
je     1e2d <Tred2+0xcfd>
cs nopw 0x0(%rax,%rax,1)
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%r15,%rcx,8)
movq   $0x0,(%rax,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    1e10 <Tred2+0xce0>
cmp    $0x3,%rdx
jb     1e9e <Tred2+0xd6e>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%r15,%rcx,8)
movq   $0x0,(%rax,%rcx,8)
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,0x8(%r15,%rcx,8)
movq   $0x0,0x8(%rax,%rcx,8)
movsd  0x10(%rax,%rcx,8),%xmm0
movsd  %xmm0,0x10(%r15,%rcx,8)
movq   $0x0,0x10(%rax,%rcx,8)
movsd  0x18(%rax,%rcx,8),%xmm0
movsd  %xmm0,0x18(%r15,%rcx,8)
movq   $0x0,0x18(%rax,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rbp
jne    1e40 <Tred2+0xd10>
mov    %r12,(%rax,%r11,8)
movq   $0x0,(%r14)
add    $0xc8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %esi,%esi
test   $0x1,%dl
jne    1dc4 <Tred2+0xc94>
jmp    1deb <Tred2+0xcbb>

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

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