#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 **a, int n, double *d, double *e) {
  int l, k, j, i;
  double scale, hh, h, g, f;
  for (i = n - 1; i >= 1; i--) {
    l = i - 1;
    h = scale = 0.0;
    if (l > 0) {
      for (k = 0; k <= l; k++)
        scale += fabs(a[i][k]);
      if (scale == 0.0)
        e[i] = a[i][l];
      else {
        for (k = 0; k <= l; k++) {
          a[i][k] /= scale;
          h += a[i][k] * a[i][k];
        }
        f = a[i][l];
        g = f > 0 ? -sqrt(h) : sqrt(h);
        e[i] = scale * g;
        h -= f * g;
        a[i][l] = f - g;
        f = 0.0;
        for (j = 0; j <= l; j++) {
          a[j][i] = a[i][j] / h;
          g = 0.0;
          for (k = 0; k <= j; k++)
            g += a[j][k] * a[i][k];
          for (k = j + 1; k <= l; k++)
            g += a[k][j] * a[i][k];
          e[j] = g / h;
          f += e[j] * a[i][j];
        }
        hh = f / (h + h);
        for (j = 0; j <= l; j++) {
          f = a[i][j];
          e[j] = g = e[j] - hh * f;
          for (k = 0; k <= j; k++)
            a[j][k] -= (f * e[k] + g * a[i][k]);
        }
      }
    } else
      e[i] = a[i][l];
    d[i] = h;
  }
  d[0] = 0.0;
  e[0] = 0.0;
  for (i = 0; i < n; i++) {
    l = i - 1;
    if (d[i]) {
      for (j = 0; j <= l; j++) {
        g = 0.0;
        for (k = 0; k <= l; k++)
          g += a[i][k] * a[k][j];
        for (k = 0; k <= l; k++)
          a[k][j] -= g * a[k][i];
      }
    }
    d[i] = a[i][i];
    a[i][i] = 1.0;
    for (j = 0; j <= l; j++)
      a[j][i] = a[i][j] = 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)
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x30(%rbp)
cmpl   $0x1,-0x30(%rbp)
jl     1615 <tred2+0x4f5>
mov    -0x30(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x24(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
cmpl   $0x0,-0x24(%rbp)
jle    15d3 <tred2+0x4b3>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     11b7 <tred2+0x97>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1030 <fabs@plt>
cvtsi2sd %rax,%xmm0
addsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1174 <tred2+0x54>
movsd  -0x38(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    11f6 <tred2+0xd6>
jp     11f6 <tred2+0xd6>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    15ce <tred2+0x4ae>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     1276 <tred2+0x156>
movsd  -0x38(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x48(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11fd <tred2+0xdd>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    12cd <tred2+0x1ad>
movsd  -0x48(%rbp),%xmm0
call   1040 <sqrt@plt>
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x60(%rbp)
jmp    12dc <tred2+0x1bc>
movsd  -0x48(%rbp),%xmm0
call   1040 <sqrt@plt>
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x38(%rbp),%xmm0
mulsd  -0x50(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm2
movsd  -0x48(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x58(%rbp),%xmm0
subsd  -0x50(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     14b6 <tred2+0x396>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x48(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jg     13fe <tred2+0x2de>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%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    13a8 <tred2+0x288>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     145d <tred2+0x33d>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%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    1407 <tred2+0x2e7>
movsd  -0x50(%rbp),%xmm0
divsd  -0x48(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%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    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    135e <tred2+0x23e>
movsd  -0x58(%rbp),%xmm0
movsd  -0x48(%rbp),%xmm1
addsd  -0x48(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     15c9 <tred2+0x4a9>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x40(%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,-0x50(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jg     15b6 <tred2+0x496>
movsd  -0x58(%rbp),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x50(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%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    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    154a <tred2+0x42a>
jmp    15bb <tred2+0x49b>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    14d5 <tred2+0x3b5>
jmp    15ce <tred2+0x4ae>
jmp    15f5 <tred2+0x4d5>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
jmp    1140 <tred2+0x20>
mov    -0x18(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
mov    -0x20(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1813 <tred2+0x6f3>
mov    -0x30(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    166c <tred2+0x54c>
jp     166c <tred2+0x54c>
jmp    1770 <tred2+0x650>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     176b <tred2+0x64b>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     16e4 <tred2+0x5c4>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%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    168e <tred2+0x56e>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     1758 <tred2+0x638>
movsd  -0x50(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%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    16eb <tred2+0x5cb>
jmp    175d <tred2+0x63d>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1673 <tred2+0x553>
jmp    1770 <tred2+0x650>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  0x856(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     1800 <tred2+0x6e0>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    17b6 <tred2+0x696>
jmp    1805 <tred2+0x6e5>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1632 <tred2+0x512>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<tred2>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    %rcx,%rbx
mov    %rdx,%r13
mov    %rdi,%r15
mov    %esi,%eax
mov    %rax,0x30(%rsp)
mov    %rsi,0x20(%rsp)
cmp    $0x2,%esi
jl     17e1 <tred2+0x6c1>
mov    0x20(%rsp),%rax
lea    -0x1(%rax),%ecx
mov    %rcx,%rax
neg    %rax
mov    %rax,0x48(%rsp)
lea    0x8(%r15),%rax
mov    %rax,0x40(%rsp)
mov    0x30(%rsp),%rdx
mov    %rcx,%rax
mov    %rcx,0x50(%rsp)
xor    %eax,%eax
mov    %rcx,%r14
mov    %r13,0x28(%rsp)
jmp    11cc <tred2+0xac>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x18(%rsp),%rcx
movsd  -0x10(%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rbx,%r12,8)
xorpd  %xmm9,%xmm9
mov    0x28(%rsp),%r13
movsd  %xmm9,0x0(%r13,%r12,8)
add    $0xffffffffffffffff,%r14
mov    0x58(%rsp),%rax
add    $0x1,%rax
cmp    $0x2,%rcx
mov    %r12,%rdx
jle    17e1 <tred2+0x6c1>
lea    -0x1(%rdx),%r12
cmp    $0x2,%rdx
je     17ca <tred2+0x6aa>
mov    %rdx,0x18(%rsp)
mov    %rax,0x58(%rsp)
mov    %rax,%rcx
not    %rcx
mov    0x50(%rsp),%rax
mov    %rcx,0x10(%rsp)
add    %rcx,%rax
cmp    $0x3,%rax
jae    1210 <tred2+0xf0>
xorpd  %xmm4,%xmm4
xor    %ebp,%ebp
jmp    12b8 <tred2+0x198>
nopl   0x0(%rax,%rax,1)
mov    %r14,%r13
and    $0xfffffffffffffffc,%r13
xorps  %xmm4,%xmm4
xor    %ebp,%ebp
nopl   0x0(%rax)
movsd  %xmm4,0x8(%rsp)
mov    (%r15,%r12,8),%rax
movsd  (%rax,%rbp,8),%xmm0
call   1030 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
addsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
mov    (%r15,%r12,8),%rax
movsd  0x8(%rax,%rbp,8),%xmm0
call   1030 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
addsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
mov    (%r15,%r12,8),%rax
movsd  0x10(%rax,%rbp,8),%xmm0
call   1030 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
addsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
mov    (%r15,%r12,8),%rax
movsd  0x18(%rax,%rbp,8),%xmm0
call   1030 <fabs@plt>
xorps  %xmm4,%xmm4
cvtsi2sd %rax,%xmm4
addsd  0x8(%rsp),%xmm4
add    $0x4,%rbp
cmp    %rbp,%r13
jne    1220 <tred2+0x100>
test   $0x3,%r14b
je     1300 <tred2+0x1e0>
mov    %r14d,%r13d
and    $0x3,%r13d
cs nopw 0x0(%rax,%rax,1)
nop
movsd  %xmm4,0x8(%rsp)
mov    (%r15,%r12,8),%rax
movsd  (%rax,%rbp,8),%xmm0
call   1030 <fabs@plt>
movsd  0x8(%rsp),%xmm4
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
addsd  %xmm0,%xmm4
add    $0x1,%rbp
add    $0xffffffffffffffff,%r13
jne    12d0 <tred2+0x1b0>
ucomisd 0xd08(%rip),%xmm4
mov    (%r15,%r12,8),%rax
jne    1314 <tred2+0x1f4>
jnp    1190 <tred2+0x70>
mov    0x10(%rsp),%rcx
cmp    0x48(%rsp),%rcx
mov    0x18(%rsp),%rbp
jne    132e <tred2+0x20e>
xorpd  %xmm9,%xmm9
xor    %ecx,%ecx
jmp    1381 <tred2+0x261>
mov    %r14,%rdx
and    $0xfffffffffffffffe,%rdx
xorpd  %xmm0,%xmm0
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movsd  (%rax,%rcx,8),%xmm1
movsd  0x8(%rax,%rcx,8),%xmm9
divsd  %xmm4,%xmm1
movsd  %xmm1,(%rax,%rcx,8)
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
divsd  %xmm4,%xmm9
movsd  %xmm9,0x8(%rax,%rcx,8)
mulsd  %xmm9,%xmm9
addsd  %xmm1,%xmm9
add    $0x2,%rcx
movapd %xmm9,%xmm0
cmp    %rcx,%rdx
jne    1340 <tred2+0x220>
test   $0x1,%r14b
je     139e <tred2+0x27e>
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm4,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm9
movsd  -0x10(%rax,%rbp,8),%xmm1
ucomisd 0xc63(%rip),%xmm9
jb     13b9 <tred2+0x299>
xorps  %xmm0,%xmm0
sqrtsd %xmm9,%xmm0
jmp    13e9 <tred2+0x2c9>
movapd %xmm9,%xmm0
movsd  %xmm9,0x10(%rsp)
movsd  %xmm4,0x8(%rsp)
movsd  %xmm1,0x38(%rsp)
call   1040 <sqrt@plt>
movsd  0x38(%rsp),%xmm1
movsd  0x8(%rsp),%xmm4
movsd  0x10(%rsp),%xmm9
movabs $0x100000000,%r8
lea    -0x2(%rbp),%r11
movapd %xmm0,%xmm2
xorpd  0xbfd(%rip),%xmm2
xorpd  %xmm8,%xmm8
xorpd  %xmm3,%xmm3
cmpltsd %xmm1,%xmm3
andpd  %xmm3,%xmm2
andnpd %xmm0,%xmm3
orpd   %xmm2,%xmm3
mulsd  %xmm3,%xmm4
movsd  %xmm4,(%rbx,%r12,8)
movapd %xmm1,%xmm0
mulsd  %xmm3,%xmm0
subsd  %xmm0,%xmm9
subsd  %xmm3,%xmm1
mov    (%r15,%r12,8),%rax
movsd  %xmm1,-0x10(%rax,%rbp,8)
lea    0x8(%rax),%r10
mov    $0x1,%r9d
mov    0x40(%rsp),%r13
mov    %r10,%rcx
xor    %esi,%esi
mov    %r12,0x8(%rsp)
mov    %r14,0x60(%rsp)
jmp    14b3 <tred2+0x393>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movabs $0x100000000,%r14
divsd  %xmm9,%xmm0
movsd  %xmm0,(%rbx,%rsi,8)
mulsd  (%rax,%rsi,8),%xmm0
addsd  %xmm0,%xmm8
add    $0x1,%r9
add    %r14,%r8
add    $0x8,%rcx
add    $0x8,%r13
mov    %r12,%rsi
mov    0x60(%rsp),%r14
cmp    %r14,%r12
mov    0x8(%rsp),%r12
je     15d0 <tred2+0x4b0>
movsd  (%rax,%rsi,8),%xmm0
divsd  %xmm9,%xmm0
mov    (%r15,%rsi,8),%rbp
movsd  %xmm0,0x0(%rbp,%r12,8)
cmp    $0x3,%rsi
jae    14e0 <tred2+0x3c0>
xor    %edx,%edx
xorpd  %xmm0,%xmm0
jmp    1538 <tred2+0x418>
cs nopw 0x0(%rax,%rax,1)
mov    %r9,%rdi
and    $0xfffffffffffffffc,%rdi
xorpd  %xmm0,%xmm0
xor    %edx,%edx
nopl   (%rax)
movsd  0x0(%rbp,%rdx,8),%xmm2
movsd  0x8(%rbp,%rdx,8),%xmm3
mulsd  (%rax,%rdx,8),%xmm2
mulsd  0x8(%rax,%rdx,8),%xmm3
addsd  %xmm0,%xmm2
movsd  0x10(%rbp,%rdx,8),%xmm4
mulsd  0x10(%rax,%rdx,8),%xmm4
addsd  %xmm2,%xmm3
movsd  0x18(%rbp,%rdx,8),%xmm0
mulsd  0x18(%rax,%rdx,8),%xmm0
addsd  %xmm3,%xmm4
addsd  %xmm4,%xmm0
add    $0x4,%rdx
cmp    %rdx,%rdi
jne    14f0 <tred2+0x3d0>
test   $0x3,%r9b
je     1578 <tred2+0x458>
mov    %r9d,%edi
and    $0x3,%edi
lea    (%rax,%rdx,8),%r12
lea    0x0(,%rdx,8),%rdx
add    %rbp,%rdx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rdx,%rbp,8),%xmm2
mulsd  (%r12,%rbp,8),%xmm2
addsd  %xmm2,%xmm0
add    $0x1,%rbp
cmp    %rbp,%rdi
jne    1560 <tred2+0x440>
lea    0x1(%rsi),%r12
cmp    %r11,%rsi
jge    1470 <tred2+0x350>
xor    %edx,%edx
mov    %r8,%rdi
movabs $0x100000000,%r14
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x0(%r13,%rdx,1),%rbp
movsd  0x0(%rbp,%rsi,8),%xmm2
mulsd  (%rcx,%rdx,1),%xmm2
addsd  %xmm2,%xmm0
mov    %rdi,%rbp
sar    $0x20,%rbp
add    %r14,%rdi
add    $0x8,%rdx
cmp    %r11,%rbp
jl     15a0 <tred2+0x480>
jmp    147a <tred2+0x35a>
nopl   0x0(%rax)
movapd %xmm9,%xmm0
addsd  %xmm9,%xmm0
xorpd  0xa1d(%rip),%xmm8
divsd  %xmm0,%xmm8
mov    $0x1,%ecx
xor    %r8d,%r8d
mov    0x28(%rsp),%r13
jmp    160d <tred2+0x4ed>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rcx
cmp    %r14,%r8
je     17c0 <tred2+0x6a0>
mov    %r8,%r9
movsd  (%rax,%r8,8),%xmm0
movapd %xmm8,%xmm2
mulsd  %xmm0,%xmm2
addsd  (%rbx,%r8,8),%xmm2
add    $0x1,%r8
movsd  %xmm2,(%rbx,%r9,8)
mov    (%r15,%r9,8),%rsi
cmp    $0x3,%r9
jae    1640 <tred2+0x520>
xor    %ebp,%ebp
jmp    1720 <tred2+0x600>
lea    (%rax,%r8,8),%rdx
lea    (%rbx,%r8,8),%rdi
lea    (%rsi,%r8,8),%rbp
cmp    %rdi,%rsi
setb   %r11b
cmp    %rbx,%rbp
seta   %r12b
cmp    %rdx,%rsi
setb   %dl
cmp    %rbp,%rax
setb   %dil
test   %r12b,%r11b
jne    1710 <tred2+0x5f0>
mov    $0x0,%ebp
and    %dil,%dl
mov    0x8(%rsp),%r12
jne    1720 <tred2+0x600>
mov    %rcx,%rdx
and    $0xfffffffffffffffc,%rdx
mov    %r8,%rbp
and    $0xfffffffffffffffc,%rbp
movapd %xmm2,%xmm3
unpcklpd %xmm2,%xmm3
movapd %xmm0,%xmm4
unpcklpd %xmm0,%xmm4
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd (%rbx,%rdi,8),%xmm5
movupd 0x10(%rbx,%rdi,8),%xmm6
movupd (%rax,%rdi,8),%xmm7
movupd 0x10(%rax,%rdi,8),%xmm1
mulpd  %xmm3,%xmm7
mulpd  %xmm3,%xmm1
mulpd  %xmm4,%xmm5
addpd  %xmm7,%xmm5
mulpd  %xmm4,%xmm6
addpd  %xmm1,%xmm6
movupd (%rsi,%rdi,8),%xmm1
subpd  %xmm5,%xmm1
movupd 0x10(%rsi,%rdi,8),%xmm5
subpd  %xmm6,%xmm5
movupd %xmm1,(%rsi,%rdi,8)
movupd %xmm5,0x10(%rsi,%rdi,8)
add    $0x4,%rdi
cmp    %rdi,%rdx
jne    16b0 <tred2+0x590>
cmp    %rbp,%r8
je     1600 <tred2+0x4e0>
jmp    1720 <tred2+0x600>
xor    %ebp,%ebp
mov    0x8(%rsp),%r12
nopw   0x0(%rax,%rax,1)
mov    %rbp,%rdx
test   $0x1,%cl
je     1753 <tred2+0x633>
movsd  (%rax,%rbp,8),%xmm1
mulsd  %xmm2,%xmm1
movsd  (%rbx,%rbp,8),%xmm3
mulsd  %xmm0,%xmm3
addsd  %xmm1,%xmm3
movsd  (%rsi,%rbp,8),%xmm1
subsd  %xmm3,%xmm1
movsd  %xmm1,(%rsi,%rbp,8)
mov    %rbp,%rdx
or     $0x1,%rdx
cmp    %rbp,%r9
je     1600 <tred2+0x4e0>
nopl   0x0(%rax)
movsd  -0x8(%r10,%rdx,8),%xmm1
mulsd  %xmm2,%xmm1
movsd  (%rbx,%rdx,8),%xmm3
mulsd  %xmm0,%xmm3
addsd  %xmm1,%xmm3
movsd  (%rsi,%rdx,8),%xmm1
subsd  %xmm3,%xmm1
movsd  0x8(%rsi,%rdx,8),%xmm3
movsd  %xmm1,(%rsi,%rdx,8)
movsd  (%r10,%rdx,8),%xmm1
mulsd  %xmm2,%xmm1
movsd  0x8(%rbx,%rdx,8),%xmm4
mulsd  %xmm0,%xmm4
addsd  %xmm1,%xmm4
subsd  %xmm4,%xmm3
movsd  %xmm3,0x8(%rsi,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%rcx
jne    1760 <tred2+0x640>
jmp    1600 <tred2+0x4e0>
nopl   0x0(%rax)
mov    0x18(%rsp),%rcx
jmp    11ab <tred2+0x8b>
mov    (%r15,%r12,8),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,(%rbx,%r12,8)
movq   $0x0,0x0(%r13,%r12,8)
movq   $0x0,0x0(%r13)
movq   $0x0,(%rbx)
cmpl   $0x0,0x20(%rsp)
jle    1a72 <tred2+0x952>
xor    %eax,%eax
xorpd  %xmm0,%xmm0
movapd 0x7f7(%rip),%xmm1
movabs $0x3ff0000000000000,%r8
jmp    182f <tred2+0x70f>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rax
cmp    0x30(%rsp),%rax
je     1a72 <tred2+0x952>
mov    %eax,%r11d
and    $0x3,%r11d
mov    %rax,%r10
and    $0xfffffffffffffffc,%r10
mov    %rax,%r9
add    $0xffffffffffffffff,%r9
setb   %cl
movsd  0x0(%r13,%rax,8),%xmm2
ucomisd %xmm0,%xmm2
mov    (%r15,%rax,8),%rsi
jne    185e <tred2+0x73e>
jnp    19a0 <tred2+0x880>
test   %cl,%cl
je     19a0 <tred2+0x880>
mov    %rax,%r14
and    $0xfffffffffffffffe,%r14
xor    %ebp,%ebp
jmp    188d <tred2+0x76d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbp
cmp    %rax,%rbp
je     19a0 <tred2+0x880>
xorpd  %xmm2,%xmm2
xor    %edi,%edi
cmp    $0x3,%r9
jb     18f7 <tred2+0x7d7>
nopl   0x0(%rax)
movsd  (%rsi,%rdi,8),%xmm3
movsd  0x8(%rsi,%rdi,8),%xmm4
mov    (%r15,%rdi,8),%rcx
mov    0x8(%r15,%rdi,8),%rdx
mulsd  (%rcx,%rbp,8),%xmm3
addsd  %xmm2,%xmm3
mulsd  (%rdx,%rbp,8),%xmm4
addsd  %xmm3,%xmm4
movsd  0x10(%rsi,%rdi,8),%xmm3
mov    0x10(%r15,%rdi,8),%rcx
mulsd  (%rcx,%rbp,8),%xmm3
movsd  0x18(%rsi,%rdi,8),%xmm2
mov    0x18(%r15,%rdi,8),%rcx
mulsd  (%rcx,%rbp,8),%xmm2
addsd  %xmm4,%xmm3
addsd  %xmm3,%xmm2
add    $0x4,%rdi
cmp    %rdi,%r10
jne    18a0 <tred2+0x780>
test   $0x3,%al
je     192b <tred2+0x80b>
lea    (%r15,%rdi,8),%rdx
lea    (%rsi,%rdi,8),%rdi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rdi,%rcx,8),%xmm3
mov    (%rdx,%rcx,8),%rbx
mulsd  (%rbx,%rbp,8),%xmm3
addsd  %xmm3,%xmm2
add    $0x1,%rcx
cmp    %rcx,%r11
jne    1910 <tred2+0x7f0>
xorpd  %xmm1,%xmm2
xor    %edi,%edi
cmp    $0x1,%rax
je     1978 <tred2+0x858>
nopw   0x0(%rax,%rax,1)
mov    (%r15,%rdi,8),%rcx
movsd  (%rcx,%rax,8),%xmm3
mulsd  %xmm2,%xmm3
addsd  (%rcx,%rbp,8),%xmm3
movsd  %xmm3,(%rcx,%rbp,8)
mov    0x8(%r15,%rdi,8),%rcx
movsd  (%rcx,%rax,8),%xmm3
mulsd  %xmm2,%xmm3
addsd  (%rcx,%rbp,8),%xmm3
movsd  %xmm3,(%rcx,%rbp,8)
add    $0x2,%rdi
cmp    %rdi,%r14
jne    1940 <tred2+0x820>
test   $0x1,%al
je     1880 <tred2+0x760>
mov    (%r15,%rdi,8),%rcx
mulsd  (%rcx,%rax,8),%xmm2
addsd  (%rcx,%rbp,8),%xmm2
movsd  %xmm2,(%rcx,%rbp,8)
jmp    1880 <tred2+0x760>
nopl   0x0(%rax,%rax,1)
movsd  (%rsi,%rax,8),%xmm2
movsd  %xmm2,0x0(%r13,%rax,8)
mov    %r8,(%rsi,%rax,8)
test   %rax,%rax
je     1820 <tred2+0x700>
xor    %ecx,%ecx
cmp    $0x3,%r9
jb     1a2f <tred2+0x90f>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movq   $0x0,(%rsi,%rcx,8)
mov    (%r15,%rcx,8),%rdx
movq   $0x0,(%rdx,%rax,8)
movq   $0x0,0x8(%rsi,%rcx,8)
mov    0x8(%r15,%rcx,8),%rdx
movq   $0x0,(%rdx,%rax,8)
movq   $0x0,0x10(%rsi,%rcx,8)
mov    0x10(%r15,%rcx,8),%rdx
movq   $0x0,(%rdx,%rax,8)
movq   $0x0,0x18(%rsi,%rcx,8)
mov    0x18(%r15,%rcx,8),%rdx
movq   $0x0,(%rdx,%rax,8)
add    $0x4,%rcx
cmp    %rcx,%r10
jne    19d0 <tred2+0x8b0>
test   $0x3,%al
je     1820 <tred2+0x700>
lea    (%r15,%rcx,8),%rdx
lea    (%rsi,%rcx,8),%rcx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movq   $0x0,(%rcx,%rsi,8)
mov    (%rdx,%rsi,8),%rdi
movq   $0x0,(%rdi,%rax,8)
add    $0x1,%rsi
cmp    %rsi,%r11
jne    1a50 <tred2+0x930>
jmp    1820 <tred2+0x700>
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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