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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
scalar_t__ fabs(double);
double sqrt(double);
void tred2(double **V, int n, double *d, double *e) {
  int i, j, k;
  double scale, h, hh, f, g;
  for (j = 0; j < n; j++) {
    d[j] = V[n - 1][j];
  }
  for (i = n - 1; i > 0; i--) {
    scale = 0.0;
    h = 0.0;
    for (k = 0; k < i; k++) {
      scale += fabs(d[k]);
    }
    if (scale == 0.0) {
      e[i] = d[i - 1];
      for (j = 0; j < i; j++) {
        d[j] = V[i - 1][j];
        V[i][j] = 0.0;
        V[j][i] = 0.0;
      }
    } else {
      for (k = 0; k < i; k++) {
        d[k] /= scale;
        h += d[k] * d[k];
      }
      f = d[i - 1];
      g = sqrt(h);
      if (f > 0) {
        g = -g;
      }
      e[i] = scale * g;
      h = h - f * g;
      d[i - 1] = f - g;
      for (j = 0; j < i; j++) {
        e[j] = 0.0;
      }
      for (j = 0; j < i; j++) {
        f = d[j];
        V[j][i] = f;
        g = e[j] + V[j][j] * f;
        for (k = j + 1; k <= i - 1; k++) {
          g += V[k][j] * d[k];
          e[k] += V[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 - 1; k++) {
          V[k][j] -= (f * e[k] + g * d[k]);
        }
        d[j] = V[i - 1][j];
        V[i][j] = 0.0;
      }
    }
    d[i] = h;
  }
  for (i = 0; i < n - 1; i++) {
    V[n - 1][i] = V[i][i];
    V[i][i] = 1.0;
    h = d[i + 1];
    if (h != 0.0) {
      for (k = 0; k <= i; k++) {
        d[k] = V[k][i + 1] / h;
      }
      for (j = 0; j <= i; j++) {
        g = 0.0;
        for (k = 0; k <= i; k++) {
          g += V[k][i + 1] * V[k][j];
        }
        for (k = 0; k <= i; k++) {
          V[k][j] -= g * d[k];
        }
      }
    }
    for (k = 0; k <= i; k++) {
      V[k][i + 1] = 0.0;
    }
  }
  for (j = 0; j < n; j++) {
    d[j] = V[n - 1][j];
    V[n - 1][j] = 0.0;
  }
  V[n - 1][n - 1] = 1.0;
  e[0] = 0.0;
}


x86 assembly (clang, -O0):
<tred2>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    117f <tred2+0x5f>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    113e <tred2+0x1e>
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x0,-0x24(%rbp)
jle    1717 <tred2+0x5f7>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    11e4 <tred2+0xc4>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1030 <fabs@plt>
cvtsi2sd %rax,%xmm0
addsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11a9 <tred2+0x89>
movsd  -0x38(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1298 <tred2+0x178>
jp     1298 <tred2+0x178>
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1293 <tred2+0x173>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1222 <tred2+0x102>
jmp    16f7 <tred2+0x5d7>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1300 <tred2+0x1e0>
movsd  -0x38(%rbp),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x40(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    129f <tred2+0x17f>
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x40(%rbp),%xmm0
call   1040 <sqrt@plt>
movsd  %xmm0,-0x58(%rbp)
movsd  -0x50(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1359 <tred2+0x239>
movsd  -0x58(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x38(%rbp),%xmm0
mulsd  -0x58(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x40(%rbp),%xmm1
movsd  -0x50(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x50(%rbp),%xmm0
subsd  -0x58(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    13f0 <tred2+0x2d0>
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    13c6 <tred2+0x2a6>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1513 <tred2+0x3f3>
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x50(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     14f3 <tred2+0x3d3>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x50(%rbp),%xmm2
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    146c <tred2+0x34c>
movsd  -0x58(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    13f7 <tred2+0x2d7>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1583 <tred2+0x463>
movsd  -0x40(%rbp),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1522 <tred2+0x402>
movsd  -0x50(%rbp),%xmm0
movsd  -0x40(%rbp),%xmm1
addsd  -0x40(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    15ff <tred2+0x4df>
movsd  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    15a2 <tred2+0x482>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    16f2 <tred2+0x5d2>
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     16a5 <tred2+0x585>
movsd  -0x50(%rbp),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x58(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    163c <tred2+0x51c>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1606 <tred2+0x4e6>
jmp    16f7 <tred2+0x5d7>
movsd  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    1188 <tred2+0x68>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    194e <tred2+0x82e>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsd  0x88a(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x40(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    17af <tred2+0x68f>
jp     17af <tred2+0x68f>
jmp    18fd <tred2+0x7dd>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     17fc <tred2+0x6dc>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x40(%rbp),%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    17b6 <tred2+0x696>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     18f8 <tred2+0x7d8>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     1879 <tred2+0x759>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    181e <tred2+0x6fe>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     18e5 <tred2+0x7c5>
movsd  -0x58(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1880 <tred2+0x760>
jmp    18ea <tred2+0x7ca>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1803 <tred2+0x6e3>
jmp    18fd <tred2+0x7dd>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     193b <tred2+0x81b>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1904 <tred2+0x7e4>
jmp    1940 <tred2+0x820>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    171e <tred2+0x5fe>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    19b3 <tred2+0x893>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1955 <tred2+0x835>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  0x62b(%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    $0x78,%rsp
mov    %rcx,%r12
mov    %rdx,%r15
mov    %rdi,%r14
lea    -0x1(%rsi),%edx
movabs $0x3ff0000000000000,%r13
test   %esi,%esi
jle    1d4c <tred2+0xc1c>
mov    %edx,%r9d
mov    (%r14,%r9,8),%rax
mov    %esi,%ebx
cmp    $0x4,%esi
mov    %edx,0x4c(%rsp)
jb     1188 <tred2+0x58>
lea    (%rax,%rbx,8),%rcx
cmp    %r15,%rcx
jbe    1200 <tred2+0xd0>
lea    (%r15,%rbx,8),%rcx
cmp    %rcx,%rax
jae    1200 <tred2+0xd0>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %rbx,%rdx
mov    %rbx,%rdi
and    $0x3,%rdi
je     11b5 <tred2+0x85>
nopl   0x0(%rax)
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%r15,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdi
jne    11a0 <tred2+0x70>
cmp    $0x3,%rdx
jb     12e8 <tred2+0x1b8>
nop
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%r15,%rcx,8)
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,0x8(%r15,%rcx,8)
movsd  0x10(%rax,%rcx,8),%xmm0
movsd  %xmm0,0x10(%r15,%rcx,8)
movsd  0x18(%rax,%rcx,8),%xmm0
movsd  %xmm0,0x18(%r15,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rbx
jne    11c0 <tred2+0x90>
jmp    12e8 <tred2+0x1b8>
mov    %ebx,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rdi
mov    %rdi,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %edx,%r8d
and    $0x3,%r8d
cmp    $0xc,%rdi
jae    1228 <tred2+0xf8>
xor    %edi,%edi
jmp    12a4 <tred2+0x174>
movabs $0x7ffffffffffffffe,%rdi
ff ff 7f
add    $0xfffffffffffffffe,%rdi
and    %rdi,%rdx
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movups (%rax,%rdi,8),%xmm0
movups 0x10(%rax,%rdi,8),%xmm1
movups %xmm0,(%r15,%rdi,8)
movups %xmm1,0x10(%r15,%rdi,8)
movups 0x20(%rax,%rdi,8),%xmm0
movups 0x30(%rax,%rdi,8),%xmm1
movups %xmm0,0x20(%r15,%rdi,8)
movups %xmm1,0x30(%r15,%rdi,8)
movups 0x40(%rax,%rdi,8),%xmm0
movups 0x50(%rax,%rdi,8),%xmm1
movups %xmm0,0x40(%r15,%rdi,8)
movups %xmm1,0x50(%r15,%rdi,8)
movupd 0x60(%rax,%rdi,8),%xmm0
movupd 0x70(%rax,%rdi,8),%xmm1
movupd %xmm0,0x60(%r15,%rdi,8)
movupd %xmm1,0x70(%r15,%rdi,8)
add    $0x10,%rdi
add    $0xfffffffffffffffc,%rdx
jne    1240 <tred2+0x110>
test   %r8,%r8
je     12df <tred2+0x1af>
lea    (%r15,%rdi,8),%rdx
add    $0x10,%rdx
lea    (%rax,%rdi,8),%rdi
add    $0x10,%rdi
shl    $0x5,%r8
xor    %ebp,%ebp
nop
movupd -0x10(%rdi,%rbp,1),%xmm0
movupd (%rdi,%rbp,1),%xmm1
movupd %xmm0,-0x10(%rdx,%rbp,1)
movupd %xmm1,(%rdx,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%r8
jne    12c0 <tred2+0x190>
cmp    %rbx,%rcx
jne    118a <tred2+0x5a>
mov    %rbx,0x30(%rsp)
mov    %rsi,0x10(%rsp)
cmp    $0x2,%esi
jl     1d2a <tred2+0xbfa>
lea    0x0(,%r9,8),%rax
mov    %rax,0x70(%rsp)
mov    0x30(%rsp),%r13
add    $0xffffffffffffffff,%r13
lea    0x8(%r12),%rbx
lea    0x8(%r15),%rbp
lea    0x8(%r14),%r10
xor    %eax,%eax
mov    %rax,0x40(%rsp)
mov    %r12,0x50(%rsp)
mov    %r9,0x18(%rsp)
mov    %rbx,0x38(%rsp)
mov    %rbp,0x28(%rsp)
mov    %r10,0x58(%rsp)
jmp    1363 <tred2+0x233>
movsd  %xmm8,(%r15,%r13,8)
mov    0x40(%rsp),%rcx
add    $0x1,%rcx
mov    %r11,%r13
mov    %rcx,%rax
mov    %rcx,0x40(%rsp)
cmp    %r9,%rcx
je     1ab8 <tred2+0x988>
lea    -0x1(%r13),%rax
mov    %r13d,%ebp
and    $0x3,%ebp
mov    %rax,0x60(%rsp)
cmp    $0x3,%rax
jae    1390 <tred2+0x260>
xor    %r12d,%r12d
xorpd  %xmm4,%xmm4
jmp    142c <tred2+0x2fc>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r13,%rbx
and    $0xfffffffffffffffc,%rbx
xorps  %xmm4,%xmm4
xor    %r12d,%r12d
nopl   (%rax)
movsd  %xmm4,0x8(%rsp)
movsd  (%r15,%r12,8),%xmm0
call   1040 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
addsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x8(%r15,%r12,8),%xmm0
call   1040 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
addsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x10(%r15,%r12,8),%xmm0
call   1040 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
addsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x18(%r15,%r12,8),%xmm0
call   1040 <fabs@plt>
xorps  %xmm4,%xmm4
cvtsi2sd %rax,%xmm4
addsd  0x8(%rsp),%xmm4
add    $0x4,%r12
cmp    %r12,%rbx
jne    13a0 <tred2+0x270>
test   %rbp,%rbp
je     1472 <tred2+0x342>
mov    %rbp,%rax
lea    (%r15,%r12,8),%r12
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movsd  %xmm4,0x8(%rsp)
movsd  (%r12,%rbp,8),%xmm0
mov    %rax,%rbx
call   1040 <fabs@plt>
movsd  0x8(%rsp),%xmm4
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
mov    %rbx,%rax
addsd  %xmm0,%xmm4
add    $0x1,%rbp
cmp    %rbp,%rbx
jne    1440 <tred2+0x310>
ucomisd 0xb96(%rip),%xmm4
mov    0x28(%rsp),%rbp
mov    0x58(%rsp),%r10
jne    1530 <tred2+0x400>
jp     1530 <tred2+0x400>
mov    %r13,%r11
movsd  -0x8(%r15,%r13,8),%xmm0
mov    0x50(%rsp),%r12
movsd  %xmm0,(%r12,%r13,8)
mov    -0x8(%r14,%r13,8),%rcx
mov    (%r14,%r13,8),%rax
add    $0xffffffffffffffff,%r11
mov    0x18(%rsp),%r9
je     15a0 <tred2+0x470>
mov    %r13,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %edx,%edx
mov    0x10(%rsp),%r8
movapd 0xb2d(%rip),%xmm7
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rcx,%rdx,8),%xmm0
movsd  %xmm0,-0x8(%rbp,%rdx,8)
movq   $0x0,(%rax,%rdx,8)
mov    -0x8(%r10,%rdx,8),%rdi
movq   $0x0,(%rdi,%r13,8)
movsd  0x8(%rcx,%rdx,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rdx,8)
movq   $0x0,0x8(%rax,%rdx,8)
mov    (%r10,%rdx,8),%rdi
movq   $0x0,(%rdi,%r13,8)
add    $0x2,%rdx
cmp    %rdx,%rsi
jne    14e0 <tred2+0x3b0>
jmp    15af <tred2+0x47f>
nop
cmpq   $0x0,0x60(%rsp)
mov    0x50(%rsp),%r12
je     15e2 <tred2+0x4b2>
mov    %r13,%rcx
and    $0xfffffffffffffffe,%rcx
xorpd  %xmm0,%xmm0
xor    %eax,%eax
xchg   %ax,%ax
movsd  (%r15,%rax,8),%xmm1
movsd  0x8(%r15,%rax,8),%xmm3
divsd  %xmm4,%xmm1
movsd  %xmm1,(%r15,%rax,8)
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
divsd  %xmm4,%xmm3
movsd  %xmm3,0x8(%r15,%rax,8)
mulsd  %xmm3,%xmm3
addsd  %xmm1,%xmm3
add    $0x2,%rax
movapd %xmm3,%xmm0
cmp    %rax,%rcx
jne    1550 <tred2+0x420>
jmp    15e8 <tred2+0x4b8>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xor    %edx,%edx
mov    0x10(%rsp),%r8
movapd 0xa51(%rip),%xmm7
xorpd  %xmm8,%xmm8
test   $0x1,%r13b
je     1340 <tred2+0x210>
movsd  (%rcx,%rdx,8),%xmm0
movsd  %xmm0,(%r15,%rdx,8)
movq   $0x0,(%rax,%rdx,8)
mov    (%r14,%rdx,8),%rax
movq   $0x0,(%rax,%r13,8)
jmp    1340 <tred2+0x210>
xorpd  %xmm3,%xmm3
xor    %eax,%eax
mov    0x40(%rsp),%rcx
lea    0x0(,%rcx,8),%rcx
test   $0x1,%r13b
je     1613 <tred2+0x4e3>
movsd  (%r15,%rax,8),%xmm0
divsd  %xmm4,%xmm0
movsd  %xmm0,(%r15,%rax,8)
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm3
mov    0x70(%rsp),%rbx
sub    %rcx,%rbx
movsd  -0x8(%r15,%r13,8),%xmm5
ucomisd 0x9e6(%rip),%xmm3
jb     1635 <tred2+0x505>
xorps  %xmm0,%xmm0
sqrtsd %xmm3,%xmm0
jmp    1662 <tred2+0x532>
movapd %xmm3,%xmm0
movsd  %xmm3,0x20(%rsp)
movsd  %xmm4,0x8(%rsp)
movsd  %xmm5,0x68(%rsp)
call   1050 <sqrt@plt>
movsd  0x68(%rsp),%xmm5
movsd  0x8(%rsp),%xmm4
movsd  0x20(%rsp),%xmm3
movapd 0x996(%rip),%xmm2
movapd %xmm0,%xmm1
xorpd  %xmm2,%xmm1
xorpd  %xmm2,%xmm2
cmpltsd %xmm5,%xmm2
andpd  %xmm2,%xmm1
andnpd %xmm0,%xmm2
orpd   %xmm1,%xmm2
mulsd  %xmm2,%xmm4
movsd  %xmm4,(%r12,%r13,8)
movapd %xmm5,%xmm0
mulsd  %xmm2,%xmm0
subsd  %xmm0,%xmm3
movsd  %xmm3,0x20(%rsp)
subsd  %xmm2,%xmm5
movsd  %xmm5,-0x8(%r15,%r13,8)
mov    %r12,%rdi
xor    %esi,%esi
mov    %rbx,%rdx
call   1030 <memset@plt>
movabs $0x200000000,%r9
mov    0x58(%rsp),%r10
mov    0x28(%rsp),%rdx
mov    0x38(%rsp),%rsi
xor    %edi,%edi
movabs $0x100000000,%r11
jmp    170d <tred2+0x5dd>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  %xmm0,(%r12,%rdi,8)
add    $0x8,%rsi
add    $0x8,%rdx
add    $0x8,%r10
add    %r11,%r9
mov    %r8,%rdi
cmp    %r13,%r8
je     1780 <tred2+0x650>
movsd  (%r15,%rdi,8),%xmm1
mov    (%r14,%rdi,8),%rax
movsd  %xmm1,(%rax,%r13,8)
movsd  (%rax,%rdi,8),%xmm0
mulsd  %xmm1,%xmm0
addsd  (%r12,%rdi,8),%xmm0
lea    0x1(%rdi),%r8
cmp    %r13,%r8
jge    16f0 <tred2+0x5c0>
mov    %r9,%rcx
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
mov    (%r10,%rbp,1),%rbx
movsd  (%rbx,%rdi,8),%xmm2
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    %r11,%rcx
cmp    %r13,%rax
jl     1740 <tred2+0x610>
jmp    16f0 <tred2+0x5c0>
nopl   0x0(%rax)
mov    0x60(%rsp),%r11
test   %r11,%r11
je     18c8 <tred2+0x798>
mov    %r13,%rcx
and    $0xfffffffffffffffe,%rcx
xorpd  %xmm1,%xmm1
xor    %eax,%eax
mov    0x18(%rsp),%r9
mov    0x10(%rsp),%r8
movapd 0x853(%rip),%xmm7
mov    0x38(%rsp),%rbx
mov    0x28(%rsp),%rbp
movsd  0x20(%rsp),%xmm8
xchg   %ax,%ax
movsd  -0x8(%rbx,%rax,8),%xmm2
movsd  (%rbx,%rax,8),%xmm0
divsd  %xmm8,%xmm2
movsd  %xmm2,-0x8(%rbx,%rax,8)
mulsd  -0x8(%rbp,%rax,8),%xmm2
divsd  %xmm8,%xmm0
movsd  %xmm0,(%rbx,%rax,8)
mulsd  0x0(%rbp,%rax,8),%xmm0
addsd  %xmm1,%xmm2
addsd  %xmm2,%xmm0
add    $0x2,%rax
movapd %xmm0,%xmm1
cmp    %rax,%rcx
jne    17c0 <tred2+0x690>
test   $0x1,%r13b
je     1822 <tred2+0x6f2>
movsd  (%r12,%rax,8),%xmm1
divsd  %xmm8,%xmm1
movsd  %xmm1,(%r12,%rax,8)
mulsd  (%r15,%rax,8),%xmm1
addsd  %xmm1,%xmm0
movapd %xmm8,%xmm1
addsd  %xmm8,%xmm1
xorpd  %xmm7,%xmm0
divsd  %xmm1,%xmm0
cmp    $0x4,%r13
jb     1854 <tred2+0x724>
lea    (%r15,%r13,8),%rax
cmp    %r12,%rax
jbe    1900 <tred2+0x7d0>
lea    (%r12,%r13,8),%rax
cmp    %r15,%rax
jbe    1900 <tred2+0x7d0>
xor    %eax,%eax
mov    %rax,%rcx
or     $0x1,%rcx
test   $0x1,%r13b
je     187c <tred2+0x74c>
movsd  (%r15,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%r12,%rax,8),%xmm1
movsd  %xmm1,(%r12,%rax,8)
mov    %rcx,%rax
cmp    %rcx,%r13
je     1a00 <tred2+0x8d0>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  -0x8(%rbp,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  -0x8(%rbx,%rax,8),%xmm1
movsd  %xmm1,-0x8(%rbx,%rax,8)
movsd  0x0(%rbp,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rbx,%rax,8),%xmm1
movsd  %xmm1,(%rbx,%rax,8)
add    $0x2,%rax
cmp    %rax,%r13
jne    1890 <tred2+0x760>
jmp    1a00 <tred2+0x8d0>
xorpd  %xmm0,%xmm0
xor    %eax,%eax
mov    0x18(%rsp),%r9
mov    0x10(%rsp),%r8
movapd 0x720(%rip),%xmm7
mov    0x38(%rsp),%rbx
mov    0x28(%rsp),%rbp
movsd  0x20(%rsp),%xmm8
test   $0x1,%r13b
jne    1807 <tred2+0x6d7>
jmp    1822 <tred2+0x6f2>
mov    %r13,%rax
and    $0xfffffffffffffffc,%rax
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x4(%rax),%rcx
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     1aa8 <tred2+0x978>
mov    %rdx,%rsi
movabs $0x7ffffffffffffffe,%rcx
ff ff 7f
and    %rcx,%rsi
xor    %ecx,%ecx
nopl   0x0(%rax)
movupd (%r15,%rcx,8),%xmm2
movupd 0x10(%r15,%rcx,8),%xmm3
mulpd  %xmm1,%xmm2
movupd (%r12,%rcx,8),%xmm4
addpd  %xmm2,%xmm4
movupd 0x10(%r12,%rcx,8),%xmm2
movupd 0x20(%r12,%rcx,8),%xmm5
movupd 0x30(%r12,%rcx,8),%xmm6
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm4,(%r12,%rcx,8)
movupd %xmm3,0x10(%r12,%rcx,8)
movupd 0x20(%r15,%rcx,8),%xmm2
movupd 0x30(%r15,%rcx,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm5,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm6,%xmm3
movupd %xmm2,0x20(%r12,%rcx,8)
movupd %xmm3,0x30(%r12,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rsi
jne    1940 <tred2+0x810>
test   $0x1,%dl
je     19f7 <tred2+0x8c7>
movupd (%r15,%rcx,8),%xmm2
movupd 0x10(%r15,%rcx,8),%xmm3
movupd (%r12,%rcx,8),%xmm4
movupd 0x10(%r12,%rcx,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,(%r12,%rcx,8)
movupd %xmm3,0x10(%r12,%rcx,8)
cmp    %rax,%r13
jne    1856 <tred2+0x726>
mov    -0x8(%r14,%r13,8),%rax
mov    (%r14,%r13,8),%rcx
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movsd  (%r15,%rdx,8),%xmm0
movsd  (%r12,%rdx,8),%xmm1
movapd %xmm1,%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm2,%xmm2
mov    (%r14,%rdx,8),%rsi
movsd  (%rsi,%rdx,8),%xmm3
subsd  %xmm2,%xmm3
movsd  %xmm3,(%rsi,%rdx,8)
lea    0x1(%rdx),%rsi
cmp    %r13,%rsi
jge    1a83 <tred2+0x953>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%r15,%rsi,8),%xmm2
mulsd  %xmm1,%xmm2
movsd  (%r12,%rsi,8),%xmm3
mulsd  %xmm0,%xmm3
addsd  %xmm2,%xmm3
mov    (%r14,%rsi,8),%rdi
movsd  (%rdi,%rdx,8),%xmm2
subsd  %xmm3,%xmm2
movsd  %xmm2,(%rdi,%rdx,8)
add    $0x1,%rsi
cmp    %r13,%rsi
jl     1a50 <tred2+0x920>
movsd  (%rax,%rdx,8),%xmm0
movsd  %xmm0,(%r15,%rdx,8)
movq   $0x0,(%rcx,%rdx,8)
add    $0x1,%rdx
cmp    %r13,%rdx
jne    1a10 <tred2+0x8e0>
jmp    1340 <tred2+0x210>
xor    %ecx,%ecx
test   $0x1,%dl
jne    19c0 <tred2+0x890>
jmp    19f7 <tred2+0x8c7>
cmp    $0x2,%r8d
movabs $0x3ff0000000000000,%r13
jl     1d2a <tred2+0xbfa>
mov    (%r14,%r9,8),%r8
mov    $0x1,%r10d
xor    %edx,%edx
xorpd  %xmm0,%xmm0
jmp    1aed <tred2+0x9bd>
xchg   %ax,%ax
add    $0x1,%r10
cmp    %r9,%rdx
je     1d2a <tred2+0xbfa>
mov    %rdx,%r9
mov    %r10d,%esi
and    $0x3,%esi
mov    %r10,%r11
and    $0xfffffffffffffffc,%r11
mov    (%r14,%rdx,8),%rax
movsd  (%rax,%rdx,8),%xmm1
movsd  %xmm1,(%r8,%rdx,8)
mov    %r13,(%rax,%rdx,8)
add    $0x1,%rdx
movsd  0x8(%r15,%r9,8),%xmm1
ucomisd %xmm0,%xmm1
jne    1b27 <tred2+0x9f7>
jnp    1ca0 <tred2+0xb70>
mov    %r10,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %eax,%eax
test   %r9,%r9
je     1b71 <tred2+0xa41>
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%r14,%rax,8),%rdi
movsd  (%rdi,%rdx,8),%xmm2
divsd  %xmm1,%xmm2
movsd  %xmm2,(%r15,%rax,8)
mov    0x8(%r14,%rax,8),%rdi
movsd  (%rdi,%rdx,8),%xmm2
divsd  %xmm1,%xmm2
movsd  %xmm2,0x8(%r15,%rax,8)
add    $0x2,%rax
cmp    %rax,%rcx
jne    1b40 <tred2+0xa10>
test   $0x1,%r10b
je     1b8a <tred2+0xa5a>
mov    (%r14,%rax,8),%rdi
movsd  (%rdi,%rdx,8),%xmm2
divsd  %xmm1,%xmm2
movsd  %xmm2,(%r15,%rax,8)
xor    %ebp,%ebp
jmp    1b9d <tred2+0xa6d>
xchg   %ax,%ax
add    $0x1,%rbp
cmp    %r10,%rbp
je     1ca0 <tred2+0xb70>
xorpd  %xmm1,%xmm1
xor    %eax,%eax
cmp    $0x3,%r9
jb     1c04 <tred2+0xad4>
nopl   0x0(%rax)
mov    (%r14,%rax,8),%rdi
mov    0x8(%r14,%rax,8),%rbx
movsd  (%rdi,%rdx,8),%xmm2
mulsd  (%rdi,%rbp,8),%xmm2
addsd  %xmm1,%xmm2
movsd  (%rbx,%rdx,8),%xmm3
mulsd  (%rbx,%rbp,8),%xmm3
addsd  %xmm2,%xmm3
mov    0x10(%r14,%rax,8),%rdi
movsd  (%rdi,%rdx,8),%xmm2
mulsd  (%rdi,%rbp,8),%xmm2
mov    0x18(%r14,%rax,8),%rdi
movsd  (%rdi,%rdx,8),%xmm1
mulsd  (%rdi,%rbp,8),%xmm1
addsd  %xmm3,%xmm2
addsd  %xmm2,%xmm1
add    $0x4,%rax
cmp    %rax,%r11
jne    1bb0 <tred2+0xa80>
test   $0x3,%r10b
je     1c2b <tred2+0xafb>
lea    (%r14,%rax,8),%rax
xor    %edi,%edi
mov    (%rax,%rdi,8),%rbx
movsd  (%rbx,%rdx,8),%xmm2
mulsd  (%rbx,%rbp,8),%xmm2
addsd  %xmm2,%xmm1
add    $0x1,%rdi
cmp    %rdi,%rsi
jne    1c10 <tred2+0xae0>
xorpd  %xmm7,%xmm1
xor    %eax,%eax
test   %r9,%r9
je     1c7b <tred2+0xb4b>
cs nopw 0x0(%rax,%rax,1)
mov    (%r14,%rax,8),%rdi
movsd  (%r15,%rax,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rdi,%rbp,8),%xmm2
movsd  %xmm2,(%rdi,%rbp,8)
mov    0x8(%r14,%rax,8),%rdi
movsd  0x8(%r15,%rax,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rdi,%rbp,8),%xmm2
movsd  %xmm2,(%rdi,%rbp,8)
add    $0x2,%rax
cmp    %rax,%rcx
jne    1c40 <tred2+0xb10>
test   $0x1,%r10b
je     1b90 <tred2+0xa60>
mulsd  (%r15,%rax,8),%xmm1
mov    (%r14,%rax,8),%rax
addsd  (%rax,%rbp,8),%xmm1
movsd  %xmm1,(%rax,%rbp,8)
jmp    1b90 <tred2+0xa60>
xchg   %ax,%ax
xor    %eax,%eax
cmp    $0x3,%r9
jae    1cb0 <tred2+0xb80>
mov    0x18(%rsp),%r9
jmp    1cfc <tred2+0xbcc>
nop
mov    0x18(%rsp),%r9
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%r14,%rax,8),%rcx
movq   $0x0,(%rcx,%rdx,8)
mov    0x8(%r14,%rax,8),%rcx
movq   $0x0,(%rcx,%rdx,8)
mov    0x10(%r14,%rax,8),%rcx
movq   $0x0,(%rcx,%rdx,8)
mov    0x18(%r14,%rax,8),%rcx
movq   $0x0,(%rcx,%rdx,8)
add    $0x4,%rax
cmp    %rax,%r11
jne    1cc0 <tred2+0xb90>
test   $0x3,%r10b
je     1ae0 <tred2+0x9b0>
lea    (%r14,%rax,8),%rax
xor    %ecx,%ecx
nopl   0x0(%rax)
mov    (%rax,%rcx,8),%rdi
movq   $0x0,(%rdi,%rdx,8)
add    $0x1,%rcx
cmp    %rcx,%rsi
jne    1d10 <tred2+0xbe0>
jmp    1ae0 <tred2+0x9b0>
mov    0x10(%rsp),%rcx
test   %ecx,%ecx
mov    0x4c(%rsp),%edx
jle    1d4c <tred2+0xc1c>
mov    (%r14,%r9,8),%rax
cmp    $0x4,%ecx
jae    1d58 <tred2+0xc28>
xor    %ecx,%ecx
mov    0x30(%rsp),%rbp
jmp    1e24 <tred2+0xcf4>
movslq %edx,%r9
mov    (%r14,%r9,8),%rax
jmp    1ece <tred2+0xd9e>
mov    0x30(%rsp),%rbp
lea    (%rax,%rbp,8),%rcx
cmp    %r15,%rcx
jbe    1d76 <tred2+0xc46>
lea    (%r15,%rbp,8),%rcx
cmp    %rcx,%rax
jae    1d76 <tred2+0xc46>
xor    %ecx,%ecx
jmp    1e24 <tred2+0xcf4>
mov    %ebp,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rsi
mov    %rsi,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rsi,%rsi
je     1ee9 <tred2+0xdb9>
mov    %rdx,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %esi,%esi
xorpd  %xmm0,%xmm0
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    1da0 <tred2+0xc70>
test   $0x1,%dl
je     1e1b <tred2+0xceb>
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     1ece <tred2+0xd9e>
mov    %rcx,%rdx
not    %rdx
add    %rbp,%rdx
mov    %rbp,%rsi
and    $0x3,%rsi
je     1e5d <tred2+0xd2d>
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    1e40 <tred2+0xd10>
cmp    $0x3,%rdx
jb     1ece <tred2+0xd9e>
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    1e70 <tred2+0xd40>
mov    %r13,(%rax,%r9,8)
movq   $0x0,(%r12)
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %esi,%esi
test   $0x1,%dl
jne    1df4 <tred2+0xcc4>
jmp    1e1b <tred2+0xceb>

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

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