#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);
scalar_t__ 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 > 0; --i) {
    l = i - 1;
    h = scale = 0.0;
    if (l > 0) {
      for (k = 0; k <= l; ++k) {
        scale += (double)fabs(a[i * N + k]);
      }
      if (scale == 0.0) {
        e[i] = a[i * N + l];
      } else {
        for (k = 0; k <= l; ++k) {
          a[i * N + k] /= scale;
          h += a[i * N + k] * a[i * N + k];
        }
        f = a[i * N + l];
        g = (double)(f >= 0.0 ? -sqrt(h) : sqrt(h));
        e[i] = scale * g;
        h -= f * g;
        a[i * N + l] = f - g;
        f = 0.0;
        for (j = 0; j <= l; ++j) {
          a[j * N + i] = a[i * N + j] / h;
          g = 0.0;
          for (k = 0; k <= j; ++k) {
            g += a[j * N + k] * a[i * N + k];
          }
          for (k = j + 1; k <= l; ++k) {
            g += a[k * N + j] * a[i * N + k];
          }
          e[j] = g / h;
          f += e[j] * a[i * N + j];
        }
        hh = f / (h + h);
        for (j = 0; j <= l; ++j) {
          f = a[i * N + j];
          e[j] = g = e[j] - hh * f;
          for (k = 0; k <= j; ++k) {
            a[j * N + k] -= (f * e[k] + g * a[i * N + k]);
          }
        }
      }
    } else {
      e[i] = a[i * N + 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 * N + k] * a[k * N + j];
        }
        for (k = 0; k <= l; ++k) {
          a[k * N + j] -= g * a[k * N + i];
        }
      }
    }
    d[i] = a[i * N + i];
    a[i * N + i] = 1.0;
    for (j = 0; j <= l; ++j) {
      a[j * N + i] = a[i * N + 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   $0x0,-0x30(%rbp)
jle    161a <tred2+0x4fa>
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    15d7 <tred2+0x4b7>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     11b8 <tred2+0x98>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%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    11f8 <tred2+0xd8>
jp     11f8 <tred2+0xd8>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    15d2 <tred2+0x4b2>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     127b <tred2+0x15b>
movsd  -0x38(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%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    11ff <tred2+0xdf>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     12c3 <tred2+0x1a3>
movsd  -0x48(%rbp),%xmm0
call   1040 <sqrt@plt>
mov    %rax,%rcx
xor    %eax,%eax
sub    %rcx,%rax
mov    %rax,-0x60(%rbp)
jmp    12d1 <tred2+0x1b1>
movsd  -0x48(%rbp),%xmm0
call   1040 <sqrt@plt>
mov    %rax,-0x60(%rbp)
mov    -0x60(%rbp),%rax
cvtsi2sd %rax,%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
mov    -0x30(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%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     14b7 <tred2+0x397>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x48(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%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     13fc <tred2+0x2dc>
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%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    13a4 <tred2+0x284>
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
mov    -0x28(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%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    1405 <tred2+0x2e5>
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
mov    -0x30(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%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    1358 <tred2+0x238>
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     15cd <tred2+0x4ad>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%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     15ba <tred2+0x49a>
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
mov    -0x30(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%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    154c <tred2+0x42c>
jmp    15bf <tred2+0x49f>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    14d6 <tred2+0x3b6>
jmp    15d2 <tred2+0x4b2>
jmp    15fa <tred2+0x4da>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%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    1820 <tred2+0x700>
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    1671 <tred2+0x551>
jp     1671 <tred2+0x551>
jmp    1779 <tred2+0x659>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     1774 <tred2+0x654>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     16eb <tred2+0x5cb>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%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    1693 <tred2+0x573>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     1761 <tred2+0x641>
movsd  -0x50(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%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    16f2 <tred2+0x5d2>
jmp    1766 <tred2+0x646>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1678 <tred2+0x558>
jmp    1779 <tred2+0x659>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  0x84b(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     180d <tred2+0x6ed>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    17c1 <tred2+0x6a1>
jmp    1812 <tred2+0x6f2>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1637 <tred2+0x517>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<tred2>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xc8,%rsp
mov    %rcx,%rbx
mov    %rdx,0x28(%rsp)
mov    %esi,%r11d
mov    %rsi,0x40(%rsp)
cmp    $0x2,%esi
mov    %rdi,(%rsp)
mov    %r11,0x10(%rsp)
jl     18b1 <tred2+0x791>
mov    %rdi,%r14
mov    0x40(%rsp),%rax
lea    -0x1(%rax),%ecx
lea    0x8(%rdi),%rax
mov    %rax,0x50(%rsp)
lea    0x0(,%r11,8),%rsi
lea    0x8(,%r11,8),%rax
mov    %rax,0xb8(%rsp)
lea    -0x1(%r11),%rax
imul   %r11,%rax
lea    0x1(%rax),%rdx
mov    %rdx,0x88(%rsp)
mov    %rcx,%rdx
neg    %rdx
mov    %rdx,0x80(%rsp)
lea    (%rdi,%rax,8),%rdx
add    $0x18,%rdx
mov    %rdx,0x58(%rsp)
mov    %rsi,%rdx
neg    %rdx
mov    %rdx,0xa8(%rsp)
lea    (%rdi,%rax,8),%r12
add    $0x8,%r12
lea    (%rdi,%rax,8),%r13
lea    0x10(%rdi),%rdx
mov    %rdx,0x78(%rsp)
xor    %edx,%edx
mov    %rax,0x90(%rsp)
mov    %rax,0x60(%rsp)
mov    %r11,%rdi
mov    %rcx,%rax
mov    %rcx,0xb0(%rsp)
mov    %rcx,0x18(%rsp)
mov    %rsi,0x70(%rsp)
jmp    1262 <tred2+0x142>
nopw   0x0(%rax,%rax,1)
mov    0x20(%rsp),%rax
add    %r15,%rax
mov    (%rsp),%r14
movsd  (%r14,%rax,8),%xmm0
mov    0x30(%rsp),%rdi
movsd  %xmm0,(%rbx,%rdi,8)
xorpd  %xmm9,%xmm9
mov    0x10(%rsp),%r11
mov    0x38(%rsp),%rdx
mov    0x28(%rsp),%rax
movsd  %xmm9,(%rax,%rdi,8)
addq   $0xffffffffffffffff,0x18(%rsp)
add    $0x1,%rdx
mov    0xa8(%rsp),%rax
add    %rax,0x58(%rsp)
sub    %r11,0x60(%rsp)
add    %rax,%r12
add    %rax,%r13
cmp    $0x2,%rcx
jle    18b1 <tred2+0x791>
lea    -0x1(%rdi),%rcx
mov    %rcx,%rax
imul   %r11,%rax
mov    %rax,0x20(%rsp)
cmp    $0x2,%rdi
je     1894 <tred2+0x774>
mov    %rdi,0x68(%rsp)
mov    %rdx,0x38(%rsp)
not    %rdx
mov    0xb0(%rsp),%rax
mov    %rdx,0x48(%rsp)
add    %rdx,%rax
cmp    $0x3,%rax
mov    %rcx,0x30(%rsp)
jae    12b0 <tred2+0x190>
xorpd  %xmm3,%xmm3
xor    %ebp,%ebp
jmp    135c <tred2+0x23c>
nop
mov    0x18(%rsp),%r15
and    $0xfffffffffffffffc,%r15
xorps  %xmm3,%xmm3
xor    %ebp,%ebp
mov    0x58(%rsp),%r14
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  %xmm3,0x8(%rsp)
movsd  -0x18(%r14,%rbp,8),%xmm0
call   1030 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
addsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  -0x10(%r14,%rbp,8),%xmm0
call   1030 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
addsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  -0x8(%r14,%rbp,8),%xmm0
call   1030 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
addsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  (%r14,%rbp,8),%xmm0
call   1030 <fabs@plt>
xorps  %xmm3,%xmm3
cvtsi2sd %rax,%xmm3
addsd  0x8(%rsp),%xmm3
add    $0x4,%rbp
cmp    %rbp,%r15
jne    12d0 <tred2+0x1b0>
testb  $0x3,0x18(%rsp)
je     13ad <tred2+0x28d>
mov    0x18(%rsp),%r15
and    $0x3,%r15d
add    0x60(%rsp),%rbp
mov    (%rsp),%rax
lea    (%rax,%rbp,8),%rbp
xor    %r14d,%r14d
nopl   0x0(%rax)
movsd  %xmm3,0x8(%rsp)
movsd  0x0(%rbp,%r14,8),%xmm0
call   1030 <fabs@plt>
movsd  0x8(%rsp),%xmm3
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
addsd  %xmm0,%xmm3
add    $0x1,%r14
cmp    %r14,%r15
jne    1380 <tred2+0x260>
mov    0x68(%rsp),%rcx
lea    -0x2(%rcx),%r15
ucomisd 0xc52(%rip),%xmm3
jne    13c6 <tred2+0x2a6>
jnp    1200 <tred2+0xe0>
mov    0x38(%rsp),%rax
imul   0x10(%rsp),%rax
mov    0x48(%rsp),%rcx
cmp    0x80(%rsp),%rcx
mov    (%rsp),%r14
jne    13ec <tred2+0x2cc>
xorpd  %xmm0,%xmm0
xor    %ecx,%ecx
jmp    143f <tred2+0x31f>
mov    0x18(%rsp),%rdx
and    $0xfffffffffffffffe,%rdx
xorpd  %xmm2,%xmm2
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%r12,%rcx,8),%xmm1
movsd  (%r12,%rcx,8),%xmm0
divsd  %xmm3,%xmm1
movsd  %xmm1,-0x8(%r12,%rcx,8)
mulsd  %xmm1,%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm3,%xmm0
movsd  %xmm0,(%r12,%rcx,8)
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
add    $0x2,%rcx
movapd %xmm0,%xmm2
cmp    %rcx,%rdx
jne    1400 <tred2+0x2e0>
mov    0x90(%rsp),%rdx
sub    %rax,%rdx
testb  $0x1,0x18(%rsp)
je     146e <tred2+0x34e>
add    0x20(%rsp),%rcx
movsd  (%r14,%rcx,8),%xmm1
divsd  %xmm3,%xmm1
movsd  %xmm1,(%r14,%rcx,8)
mulsd  %xmm1,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,0xa0(%rsp)
lea    (%r14,%rdx,8),%rcx
mov    %rcx,0x48(%rsp)
mov    0x88(%rsp),%rcx
sub    %rax,%rcx
mov    %rcx,0xc0(%rsp)
mov    0x20(%rsp),%rax
lea    (%rax,%r15,1),%rbp
movsd  (%r14,%rbp,8),%xmm1
movsd  %xmm1,0x98(%rsp)
movsd  %xmm3,0x8(%rsp)
call   1040 <sqrt@plt>
movsd  0xa0(%rsp),%xmm9
mov    %rax,%rcx
neg    %rcx
xorpd  %xmm8,%xmm8
movsd  0x98(%rsp),%xmm0
ucomisd %xmm8,%xmm0
cmovb  %rax,%rcx
xorps  %xmm1,%xmm1
cvtsi2sd %rcx,%xmm1
movsd  0x8(%rsp),%xmm2
mulsd  %xmm1,%xmm2
mov    0x30(%rsp),%rax
movsd  %xmm2,(%rbx,%rax,8)
movapd %xmm0,%xmm2
mulsd  %xmm1,%xmm2
subsd  %xmm2,%xmm9
subsd  %xmm1,%xmm0
movsd  %xmm0,(%r14,%rbp,8)
mov    $0x1,%r10d
mov    0x50(%rsp),%rcx
xor    %edx,%edx
mov    0x10(%rsp),%r11
mov    0x70(%rsp),%rbp
jmp    155a <tred2+0x43a>
nopl   0x0(%rax)
divsd  %xmm9,%xmm1
movsd  %xmm1,(%rbx,%rdx,8)
mulsd  (%r14,%r8,8),%xmm1
addsd  %xmm1,%xmm8
add    $0x1,%r10
add    %rbp,%rcx
mov    %r9,%rdx
cmp    0x18(%rsp),%r9
je     1640 <tred2+0x520>
lea    0x1(%rdx),%r9
mov    0x20(%rsp),%rax
lea    (%rdx,%rax,1),%r8
movsd  (%r14,%r8,8),%xmm1
divsd  %xmm9,%xmm1
mov    %rdx,%rsi
imul   %r11,%rsi
mov    0x30(%rsp),%rax
add    %rsi,%rax
movsd  %xmm1,(%r14,%rax,8)
test   %rdx,%rdx
je     1630 <tred2+0x510>
mov    %r10,%rax
and    $0xfffffffffffffffe,%rax
xorpd  %xmm2,%xmm2
xor    %edi,%edi
nopl   (%rax)
movsd  -0x8(%rcx,%rdi,8),%xmm3
movsd  (%rcx,%rdi,8),%xmm1
mulsd  -0x8(%r12,%rdi,8),%xmm3
mulsd  (%r12,%rdi,8),%xmm1
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm1
add    $0x2,%rdi
movapd %xmm1,%xmm2
cmp    %rdi,%rax
jne    15a0 <tred2+0x480>
test   $0x1,%r9b
je     15eb <tred2+0x4cb>
add    %rdi,%rsi
movsd  (%r14,%rsi,8),%xmm2
add    0x20(%rsp),%rdi
mulsd  (%r14,%rdi,8),%xmm2
addsd  %xmm2,%xmm1
cmp    %r15,%rdx
jge    1530 <tred2+0x410>
movslq %r10d,%rsi
mov    %r11,%rax
imul   %rsi,%rax
add    %rdx,%rax
add    $0xffffffffffffffff,%rsi
lea    (%r14,%rax,8),%rax
nopl   0x0(%rax)
movsd  (%rax),%xmm2
mulsd  0x8(%r13,%rsi,8),%xmm2
addsd  %xmm2,%xmm1
add    $0x1,%rsi
add    %rbp,%rax
cmp    %r15,%rsi
jl     1610 <tred2+0x4f0>
jmp    1530 <tred2+0x410>
xor    %edi,%edi
xorpd  %xmm1,%xmm1
test   $0x1,%r9b
jne    15d3 <tred2+0x4b3>
jmp    15eb <tred2+0x4cb>
xchg   %ax,%ax
movapd %xmm9,%xmm1
addsd  %xmm9,%xmm1
xorpd  0x9ad(%rip),%xmm8
divsd  %xmm1,%xmm8
mov    $0x1,%eax
mov    0x50(%rsp),%rcx
mov    0x78(%rsp),%rdx
xor    %r8d,%r8d
jmp    168a <tred2+0x56a>
nopl   0x0(%rax)
add    $0x1,%rax
mov    0x70(%rsp),%rsi
add    %rsi,%rdx
add    %rsi,%rcx
cmp    0x18(%rsp),%r8
je     1880 <tred2+0x760>
mov    %r8,%rdi
add    $0x1,%r8
mov    %rdi,%r9
imul   %r11,%r9
mov    0x20(%rsp),%rsi
add    %rdi,%rsi
movsd  (%r14,%rsi,8),%xmm1
movapd %xmm8,%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rbx,%rdi,8),%xmm2
movsd  %xmm2,(%rbx,%rdi,8)
cmp    $0x3,%rdi
jae    16d0 <tred2+0x5b0>
xor    %r10d,%r10d
jmp    17d0 <tred2+0x6b0>
nopw   0x0(%rax,%rax,1)
lea    (%r14,%r9,8),%r10
mov    0xb8(%rsp),%rbp
imul   %rdi,%rbp
add    0x50(%rsp),%rbp
mov    0xc0(%rsp),%rsi
add    %rdi,%rsi
lea    (%r14,%rsi,8),%r11
lea    (%rbx,%rdi,8),%rsi
add    $0x8,%rsi
cmp    %rsi,%r10
setb   %r14b
cmp    %rbx,%rbp
seta   %r15b
cmp    %r11,%r10
setb   %sil
cmp    0x48(%rsp),%rbp
seta   %r11b
test   %r15b,%r14b
jne    17c3 <tred2+0x6a3>
mov    $0x0,%r10d
and    %r11b,%sil
mov    (%rsp),%r14
mov    0x10(%rsp),%r11
jne    17d0 <tred2+0x6b0>
mov    %rax,%rsi
and    $0xfffffffffffffffc,%rsi
mov    %r8,%r10
and    $0xfffffffffffffffc,%r10
movapd %xmm2,%xmm3
unpcklpd %xmm2,%xmm3
movapd %xmm1,%xmm4
unpcklpd %xmm1,%xmm4
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movupd (%rbx,%rbp,8),%xmm5
movupd 0x10(%rbx,%rbp,8),%xmm6
movupd 0x0(%r13,%rbp,8),%xmm7
movupd 0x10(%r13,%rbp,8),%xmm0
mulpd  %xmm3,%xmm7
mulpd  %xmm3,%xmm0
mulpd  %xmm4,%xmm5
addpd  %xmm7,%xmm5
mulpd  %xmm4,%xmm6
addpd  %xmm0,%xmm6
movupd -0x10(%rdx,%rbp,8),%xmm0
subpd  %xmm5,%xmm0
movupd (%rdx,%rbp,8),%xmm5
subpd  %xmm6,%xmm5
movupd %xmm0,-0x10(%rdx,%rbp,8)
movupd %xmm5,(%rdx,%rbp,8)
add    $0x4,%rbp
cmp    %rbp,%rsi
jne    1760 <tred2+0x640>
cmp    %r10,%r8
je     1670 <tred2+0x550>
jmp    17d0 <tred2+0x6b0>
xor    %r10d,%r10d
mov    (%rsp),%r14
mov    0x10(%rsp),%r11
nop
mov    %r10,%rsi
test   $0x1,%al
je     1811 <tred2+0x6f1>
mov    0x20(%rsp),%rsi
add    %r10,%rsi
movsd  (%r14,%rsi,8),%xmm0
mulsd  %xmm2,%xmm0
movsd  (%rbx,%r10,8),%xmm3
mulsd  %xmm1,%xmm3
addsd  %xmm0,%xmm3
add    %r10,%r9
movsd  (%r14,%r9,8),%xmm0
subsd  %xmm3,%xmm0
movsd  %xmm0,(%r14,%r9,8)
mov    %r10,%rsi
or     $0x1,%rsi
cmp    %r10,%rdi
je     1670 <tred2+0x550>
nopw   0x0(%rax,%rax,1)
movsd  0x0(%r13,%rsi,8),%xmm0
mulsd  %xmm2,%xmm0
movsd  (%rbx,%rsi,8),%xmm3
mulsd  %xmm1,%xmm3
addsd  %xmm0,%xmm3
movsd  -0x8(%rcx,%rsi,8),%xmm0
subsd  %xmm3,%xmm0
movsd  (%rcx,%rsi,8),%xmm3
movsd  %xmm0,-0x8(%rcx,%rsi,8)
movsd  0x8(%r13,%rsi,8),%xmm0
mulsd  %xmm2,%xmm0
movsd  0x8(%rbx,%rsi,8),%xmm4
mulsd  %xmm1,%xmm4
addsd  %xmm0,%xmm4
subsd  %xmm4,%xmm3
movsd  %xmm3,(%rcx,%rsi,8)
add    $0x2,%rsi
cmp    %rsi,%rax
jne    1820 <tred2+0x700>
jmp    1670 <tred2+0x550>
nopl   (%rax)
mov    0x38(%rsp),%rdx
mov    0x68(%rsp),%rcx
mov    0x30(%rsp),%rdi
jmp    122b <tred2+0x10b>
mov    0x20(%rsp),%rax
movsd  (%r14,%rax,8),%xmm0
movsd  %xmm0,(%rbx,%rcx,8)
mov    0x28(%rsp),%rax
movq   $0x0,(%rax,%rcx,8)
mov    0x28(%rsp),%rax
movq   $0x0,(%rax)
movq   $0x0,(%rbx)
cmpl   $0x0,0x40(%rsp)
jle    1b5d <tred2+0xa3d>
mov    %r11,%rsi
mov    (%rsp),%r12
lea    0x8(%r12),%rax
lea    0x0(,%r11,8),%r14
mov    %r11,%rdx
shl    $0x4,%rdx
lea    (%r12,%r11,8),%r9
xor    %r11d,%r11d
xorpd  %xmm0,%xmm0
movapd 0x703(%rip),%xmm1
mov    %r9,%r13
jmp    192d <tred2+0x80d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r11
add    %r14,%rax
add    $0x8,%r13
add    $0x8,%r12
mov    0x10(%rsp),%rsi
cmp    %rsi,%r11
je     1b5d <tred2+0xa3d>
mov    %r11,%rdi
and    $0xfffffffffffffffe,%rdi
mov    0x28(%rsp),%rcx
movsd  (%rcx,%r11,8),%xmm2
mov    %r11,%r10
imul   %rsi,%r10
ucomisd %xmm0,%xmm2
jne    1952 <tred2+0x832>
jnp    1aa0 <tred2+0x980>
test   %r11,%r11
je     1aa0 <tred2+0x980>
mov    %r9,%rbp
mov    (%rsp),%rsi
xor    %r15d,%r15d
jmp    1985 <tred2+0x865>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r15
add    $0x8,%rsi
add    $0x8,%rbp
cmp    %r11,%r15
je     1aa0 <tred2+0x980>
cmp    $0x1,%r11
jne    19a0 <tred2+0x880>
xorpd  %xmm2,%xmm2
xor    %ebx,%ebx
jmp    19dd <tred2+0x8bd>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xorpd  %xmm3,%xmm3
mov    %rsi,%rcx
xor    %ebx,%ebx
nopl   0x0(%rax)
movsd  -0x8(%rax,%rbx,8),%xmm4
mulsd  (%rcx),%xmm4
movsd  (%rax,%rbx,8),%xmm2
addsd  %xmm3,%xmm4
mulsd  (%rcx,%r14,1),%xmm2
addsd  %xmm4,%xmm2
add    $0x2,%rbx
add    %rdx,%rcx
movapd %xmm2,%xmm3
cmp    %rbx,%rdi
jne    19b0 <tred2+0x890>
test   $0x1,%r11b
je     1a04 <tred2+0x8e4>
lea    (%rbx,%r10,1),%rcx
mov    (%rsp),%r8
movsd  (%r8,%rcx,8),%xmm3
imul   0x10(%rsp),%rbx
add    %r15,%rbx
mulsd  (%r8,%rbx,8),%xmm3
addsd  %xmm3,%xmm2
xorpd  %xmm1,%xmm2
cmp    $0x1,%r11
jne    1a20 <tred2+0x900>
xor    %ebx,%ebx
jmp    1a67 <tred2+0x947>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xor    %ecx,%ecx
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%r12,%rcx,1),%xmm3
mulsd  %xmm2,%xmm3
addsd  (%rsi,%rcx,1),%xmm3
movsd  %xmm3,(%rsi,%rcx,1)
movsd  0x0(%r13,%rcx,1),%xmm3
mulsd  %xmm2,%xmm3
addsd  0x0(%rbp,%rcx,1),%xmm3
movsd  %xmm3,0x0(%rbp,%rcx,1)
add    $0x2,%rbx
add    %rdx,%rcx
cmp    %rbx,%rdi
jne    1a30 <tred2+0x910>
test   $0x1,%r11b
je     1970 <tred2+0x850>
imul   0x10(%rsp),%rbx
lea    (%rbx,%r11,1),%rcx
mov    (%rsp),%r8
mulsd  (%r8,%rcx,8),%xmm2
add    %r15,%rbx
addsd  (%r8,%rbx,8),%xmm2
movsd  %xmm2,(%r8,%rbx,8)
jmp    1970 <tred2+0x850>
nopl   0x0(%rax)
mov    %r11d,%ecx
imul   0x40(%rsp),%ecx
movslq %ecx,%rcx
add    %r11,%rcx
mov    (%rsp),%rbp
movsd  0x0(%rbp,%rcx,8),%xmm2
mov    0x28(%rsp),%rsi
movsd  %xmm2,(%rsi,%r11,8)
movabs $0x3ff0000000000000,%rsi
mov    %rsi,0x0(%rbp,%rcx,8)
test   %r11,%r11
je     1910 <tred2+0x7f0>
cmp    $0x1,%r11
jne    1af0 <tred2+0x9d0>
xor    %ecx,%ecx
jmp    1b2e <tred2+0xa0e>
cs nopw 0x0(%rax,%rax,1)
nop
xor    %esi,%esi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movq   $0x0,-0x8(%rax,%rcx,8)
movq   $0x0,(%r12,%rsi,1)
movq   $0x0,(%rax,%rcx,8)
movq   $0x0,0x0(%r13,%rsi,1)
add    $0x2,%rcx
add    %rdx,%rsi
cmp    %rcx,%rdi
jne    1b00 <tred2+0x9e0>
test   $0x1,%r11b
je     1910 <tred2+0x7f0>
add    %rcx,%r10
mov    (%rsp),%rsi
movq   $0x0,(%rsi,%r10,8)
imul   0x10(%rsp),%rcx
add    %r11,%rcx
movq   $0x0,(%rsi,%rcx,8)
jmp    1910 <tred2+0x7f0>
add    $0xc8,%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 = %357, %4
%21 = load i32, i32* %12
%22 = icmp sgt i32 %21, 0
br i1 %22, label %23, label %360
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 %337
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 = load i32, i32* %6
%37 = mul nsw i32 %35, %36
%38 = load i32, i32* %10
%39 = add nsw i32 %37, %38
%40 = sext i32 %39 to i64
%41 = getelementptr inbounds double, double* %34, 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 = load i32, i32* %6
%57 = mul nsw i32 %55, %56
%58 = load i32, i32* %9
%59 = add nsw i32 %57, %58
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds double, double* %54, 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 %336
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 = load i32, i32* %6
%77 = mul nsw i32 %75, %76
%78 = load i32, i32* %10
%79 = add nsw i32 %77, %78
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds double, double* %74, 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 = load i32, i32* %6
%87 = mul nsw i32 %85, %86
%88 = load i32, i32* %10
%89 = add nsw i32 %87, %88
%90 = sext i32 %89 to i64
%91 = getelementptr inbounds double, double* %84, i64 %90
%92 = load double, double* %91
%93 = load double*, double** %5
%94 = load i32, i32* %12
%95 = load i32, i32* %6
%96 = mul nsw i32 %94, %95
%97 = load i32, i32* %10
%98 = add nsw i32 %96, %97
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds double, double* %93, 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 = load i32, i32* %6
%111 = mul nsw i32 %109, %110
%112 = load i32, i32* %9
%113 = add nsw i32 %111, %112
%114 = sext i32 %113 to i64
%115 = getelementptr inbounds double, double* %108, i64 %114
%116 = load double, double* %115
store double %116, double* %17
%117 = load double, double* %17
%118 = fcmp oge double %117, 0.000000e+00
br i1 %118, label %119, label %123
119: ; preds = %107
%120 = load double, double* %15
%121 = call i64 @sqrt(double %120)
%122 = sub nsw i64 0, %121
br label %126
123: ; preds = %107
%124 = load double, double* %15
%125 = call i64 @sqrt(double %124)
br label %126
126: ; preds = %123, %119
%127 = phi i64 [ %122, %119 ], [ %125, %123 ]
%128 = sitofp i64 %127 to double
store double %128, double* %16
%129 = load double, double* %13
%130 = load double, double* %16
%131 = fmul double %129, %130
%132 = load double*, double** %8
%133 = load i32, i32* %12
%134 = sext i32 %133 to i64
%135 = getelementptr inbounds double, double* %132, i64 %134
store double %131, double* %135
%136 = load double, double* %17
%137 = load double, double* %16
%138 = load double, double* %15
%139 = fneg double %136
%140 = call double @llvm.fmuladd.f64(double %139, double %137, double %138)
store double %140, double* %15
%141 = load double, double* %17
%142 = load double, double* %16
%143 = fsub double %141, %142
%144 = load double*, double** %5
%145 = load i32, i32* %12
%146 = load i32, i32* %6
%147 = mul nsw i32 %145, %146
%148 = load i32, i32* %9
%149 = add nsw i32 %147, %148
%150 = sext i32 %149 to i64
%151 = getelementptr inbounds double, double* %144, i64 %150
store double %143, double* %151
store double 0.000000e+00, double* %17
store i32 0, i32* %11
br label %152
152: ; preds = %259, %126
%153 = load i32, i32* %11
%154 = load i32, i32* %9
%155 = icmp sle i32 %153, %154
br i1 %155, label %156, label %262
156: ; preds = %152
%157 = load double*, double** %5
%158 = load i32, i32* %12
%159 = load i32, i32* %6
%160 = mul nsw i32 %158, %159
%161 = load i32, i32* %11
%162 = add nsw i32 %160, %161
%163 = sext i32 %162 to i64
%164 = getelementptr inbounds double, double* %157, i64 %163
%165 = load double, double* %164
%166 = load double, double* %15
%167 = fdiv double %165, %166
%168 = load double*, double** %5
%169 = load i32, i32* %11
%170 = load i32, i32* %6
%171 = mul nsw i32 %169, %170
%172 = load i32, i32* %12
%173 = add nsw i32 %171, %172
%174 = sext i32 %173 to i64
%175 = getelementptr inbounds double, double* %168, i64 %174
store double %167, double* %175
store double 0.000000e+00, double* %16
store i32 0, i32* %10
br label %176
176: ; preds = %201, %156
%177 = load i32, i32* %10
%178 = load i32, i32* %11
%179 = icmp sle i32 %177, %178
br i1 %179, label %180, label %204
180: ; preds = %176
%181 = load double*, double** %5
%182 = load i32, i32* %11
%183 = load i32, i32* %6
%184 = mul nsw i32 %182, %183
%185 = load i32, i32* %10
%186 = add nsw i32 %184, %185
%187 = sext i32 %186 to i64
%188 = getelementptr inbounds double, double* %181, i64 %187
%189 = load double, double* %188
%190 = load double*, double** %5
%191 = load i32, i32* %12
%192 = load i32, i32* %6
%193 = mul nsw i32 %191, %192
%194 = load i32, i32* %10
%195 = add nsw i32 %193, %194
%196 = sext i32 %195 to i64
%197 = getelementptr inbounds double, double* %190, i64 %196
%198 = load double, double* %197
%199 = load double, double* %16
%200 = call double @llvm.fmuladd.f64(double %189, double %198, double %199)
store double %200, double* %16
br label %201
201: ; preds = %180
%202 = load i32, i32* %10
%203 = add nsw i32 %202, 1
store i32 %203, i32* %10
br label %176
204: ; preds = %176
%205 = load i32, i32* %11
%206 = add nsw i32 %205, 1
store i32 %206, i32* %10
br label %207
207: ; preds = %232, %204
%208 = load i32, i32* %10
%209 = load i32, i32* %9
%210 = icmp sle i32 %208, %209
br i1 %210, label %211, label %235
211: ; preds = %207
%212 = load double*, double** %5
%213 = load i32, i32* %10
%214 = load i32, i32* %6
%215 = mul nsw i32 %213, %214
%216 = load i32, i32* %11
%217 = add nsw i32 %215, %216
%218 = sext i32 %217 to i64
%219 = getelementptr inbounds double, double* %212, i64 %218
%220 = load double, double* %219
%221 = load double*, double** %5
%222 = load i32, i32* %12
%223 = load i32, i32* %6
%224 = mul nsw i32 %222, %223
%225 = load i32, i32* %10
%226 = add nsw i32 %224, %225
%227 = sext i32 %226 to i64
%228 = getelementptr inbounds double, double* %221, i64 %227
%229 = load double, double* %228
%230 = load double, double* %16
%231 = call double @llvm.fmuladd.f64(double %220, double %229, double %230)
store double %231, double* %16
br label %232
232: ; preds = %211
%233 = load i32, i32* %10
%234 = add nsw i32 %233, 1
store i32 %234, i32* %10
br label %207
235: ; preds = %207
%236 = load double, double* %16
%237 = load double, double* %15
%238 = fdiv double %236, %237
%239 = load double*, double** %8
%240 = load i32, i32* %11
%241 = sext i32 %240 to i64
%242 = getelementptr inbounds double, double* %239, i64 %241
store double %238, double* %242
%243 = load double*, double** %8
%244 = load i32, i32* %11
%245 = sext i32 %244 to i64
%246 = getelementptr inbounds double, double* %243, i64 %245
%247 = load double, double* %246
%248 = load double*, double** %5
%249 = load i32, i32* %12
%250 = load i32, i32* %6
%251 = mul nsw i32 %249, %250
%252 = load i32, i32* %11
%253 = add nsw i32 %251, %252
%254 = sext i32 %253 to i64
%255 = getelementptr inbounds double, double* %248, i64 %254
%256 = load double, double* %255
%257 = load double, double* %17
%258 = call double @llvm.fmuladd.f64(double %247, double %256, double %257)
store double %258, double* %17
br label %259
259: ; preds = %235
%260 = load i32, i32* %11
%261 = add nsw i32 %260, 1
store i32 %261, i32* %11
br label %152
262: ; preds = %152
%263 = load double, double* %17
%264 = load double, double* %15
%265 = load double, double* %15
%266 = fadd double %264, %265
%267 = fdiv double %263, %266
store double %267, double* %14
store i32 0, i32* %11
br label %268
268: ; preds = %332, %262
%269 = load i32, i32* %11
%270 = load i32, i32* %9
%271 = icmp sle i32 %269, %270
br i1 %271, label %272, label %335
272: ; preds = %268
%273 = load double*, double** %5
%274 = load i32, i32* %12
%275 = load i32, i32* %6
%276 = mul nsw i32 %274, %275
%277 = load i32, i32* %11
%278 = add nsw i32 %276, %277
%279 = sext i32 %278 to i64
%280 = getelementptr inbounds double, double* %273, i64 %279
%281 = load double, double* %280
store double %281, double* %17
%282 = load double*, double** %8
%283 = load i32, i32* %11
%284 = sext i32 %283 to i64
%285 = getelementptr inbounds double, double* %282, i64 %284
%286 = load double, double* %285
%287 = load double, double* %14
%288 = load double, double* %17
%289 = fneg double %287
%290 = call double @llvm.fmuladd.f64(double %289, double %288, double %286)
store double %290, double* %16
%291 = load double*, double** %8
%292 = load i32, i32* %11
%293 = sext i32 %292 to i64
%294 = getelementptr inbounds double, double* %291, i64 %293
store double %290, double* %294
store i32 0, i32* %10
br label %295
295: ; preds = %328, %272
%296 = load i32, i32* %10
%297 = load i32, i32* %11
%298 = icmp sle i32 %296, %297
br i1 %298, label %299, label %331
299: ; preds = %295
%300 = load double, double* %17
%301 = load double*, double** %8
%302 = load i32, i32* %10
%303 = sext i32 %302 to i64
%304 = getelementptr inbounds double, double* %301, i64 %303
%305 = load double, double* %304
%306 = load double, double* %16
%307 = load double*, double** %5
%308 = load i32, i32* %12
%309 = load i32, i32* %6
%310 = mul nsw i32 %308, %309
%311 = load i32, i32* %10
%312 = add nsw i32 %310, %311
%313 = sext i32 %312 to i64
%314 = getelementptr inbounds double, double* %307, i64 %313
%315 = load double, double* %314
%316 = fmul double %306, %315
%317 = call double @llvm.fmuladd.f64(double %300, double %305, double %316)
%318 = load double*, double** %5
%319 = load i32, i32* %11
%320 = load i32, i32* %6
%321 = mul nsw i32 %319, %320
%322 = load i32, i32* %10
%323 = add nsw i32 %321, %322
%324 = sext i32 %323 to i64
%325 = getelementptr inbounds double, double* %318, i64 %324
%326 = load double, double* %325
%327 = fsub double %326, %317
store double %327, double* %325
br label %328
328: ; preds = %299
%329 = load i32, i32* %10
%330 = add nsw i32 %329, 1
store i32 %330, i32* %10
br label %295
331: ; preds = %295
br label %332
332: ; preds = %331
%333 = load i32, i32* %11
%334 = add nsw i32 %333, 1
store i32 %334, i32* %11
br label %268
335: ; preds = %268
br label %336
336: ; preds = %335, %53
br label %351
337: ; preds = %23
%338 = load double*, double** %5
%339 = load i32, i32* %12
%340 = load i32, i32* %6
%341 = mul nsw i32 %339, %340
%342 = load i32, i32* %9
%343 = add nsw i32 %341, %342
%344 = sext i32 %343 to i64
%345 = getelementptr inbounds double, double* %338, i64 %344
%346 = load double, double* %345
%347 = load double*, double** %8
%348 = load i32, i32* %12
%349 = sext i32 %348 to i64
%350 = getelementptr inbounds double, double* %347, i64 %349
store double %346, double* %350
br label %351
351: ; preds = %337, %336
%352 = load double, double* %15
%353 = load double*, double** %7
%354 = load i32, i32* %12
%355 = sext i32 %354 to i64
%356 = getelementptr inbounds double, double* %353, i64 %355
store double %352, double* %356
br label %357
357: ; preds = %351
%358 = load i32, i32* %12
%359 = add nsw i32 %358, -1
store i32 %359, i32* %12
br label %20
360: ; preds = %20
%361 = load double*, double** %7
%362 = getelementptr inbounds double, double* %361, i64 0
store double 0.000000e+00, double* %362
%363 = load double*, double** %8
%364 = getelementptr inbounds double, double* %363, i64 0
store double 0.000000e+00, double* %364
store i32 0, i32* %12
br label %365
365: ; preds = %494, %360
%366 = load i32, i32* %12
%367 = load i32, i32* %6
%368 = icmp slt i32 %366, %367
br i1 %368, label %369, label %497
369: ; preds = %365
%370 = load i32, i32* %12
%371 = sub nsw i32 %370, 1
store i32 %371, i32* %9
%372 = load double*, double** %7
%373 = load i32, i32* %12
%374 = sext i32 %373 to i64
%375 = getelementptr inbounds double, double* %372, i64 %374
%376 = load double, double* %375
%377 = fcmp une double %376, 0.000000e+00
br i1 %377, label %378, label %447
378: ; preds = %369
store i32 0, i32* %11
br label %379
379: ; preds = %443, %378
%380 = load i32, i32* %11
%381 = load i32, i32* %9
%382 = icmp sle i32 %380, %381
br i1 %382, label %383, label %446
383: ; preds = %379
store double 0.000000e+00, double* %16
store i32 0, i32* %10
br label %384
384: ; preds = %409, %383
%385 = load i32, i32* %10
%386 = load i32, i32* %9
%387 = icmp sle i32 %385, %386
br i1 %387, label %388, label %412
388: ; preds = %384
%389 = load double*, double** %5
%390 = load i32, i32* %12
%391 = load i32, i32* %6
%392 = mul nsw i32 %390, %391
%393 = load i32, i32* %10
%394 = add nsw i32 %392, %393
%395 = sext i32 %394 to i64
%396 = getelementptr inbounds double, double* %389, i64 %395
%397 = load double, double* %396
%398 = load double*, double** %5
%399 = load i32, i32* %10
%400 = load i32, i32* %6
%401 = mul nsw i32 %399, %400
%402 = load i32, i32* %11
%403 = add nsw i32 %401, %402
%404 = sext i32 %403 to i64
%405 = getelementptr inbounds double, double* %398, i64 %404
%406 = load double, double* %405
%407 = load double, double* %16
%408 = call double @llvm.fmuladd.f64(double %397, double %406, double %407)
store double %408, double* %16
br label %409
409: ; preds = %388
%410 = load i32, i32* %10
%411 = add nsw i32 %410, 1
store i32 %411, i32* %10
br label %384
412: ; preds = %384
store i32 0, i32* %10
br label %413
413: ; preds = %439, %412
%414 = load i32, i32* %10
%415 = load i32, i32* %9
%416 = icmp sle i32 %414, %415
br i1 %416, label %417, label %442
417: ; preds = %413
%418 = load double, double* %16
%419 = load double*, double** %5
%420 = load i32, i32* %10
%421 = load i32, i32* %6
%422 = mul nsw i32 %420, %421
%423 = load i32, i32* %12
%424 = add nsw i32 %422, %423
%425 = sext i32 %424 to i64
%426 = getelementptr inbounds double, double* %419, i64 %425
%427 = load double, double* %426
%428 = load double*, double** %5
%429 = load i32, i32* %10
%430 = load i32, i32* %6
%431 = mul nsw i32 %429, %430
%432 = load i32, i32* %11
%433 = add nsw i32 %431, %432
%434 = sext i32 %433 to i64
%435 = getelementptr inbounds double, double* %428, i64 %434
%436 = load double, double* %435
%437 = fneg double %418
%438 = call double @llvm.fmuladd.f64(double %437, double %427, double %436)
store double %438, double* %435
br label %439
439: ; preds = %417
%440 = load i32, i32* %10
%441 = add nsw i32 %440, 1
store i32 %441, i32* %10
br label %413
442: ; preds = %413
br label %443
443: ; preds = %442
%444 = load i32, i32* %11
%445 = add nsw i32 %444, 1
store i32 %445, i32* %11
br label %379
446: ; preds = %379
br label %447
447: ; preds = %446, %369
%448 = load double*, double** %5
%449 = load i32, i32* %12
%450 = load i32, i32* %6
%451 = mul nsw i32 %449, %450
%452 = load i32, i32* %12
%453 = add nsw i32 %451, %452
%454 = sext i32 %453 to i64
%455 = getelementptr inbounds double, double* %448, i64 %454
%456 = load double, double* %455
%457 = load double*, double** %7
%458 = load i32, i32* %12
%459 = sext i32 %458 to i64
%460 = getelementptr inbounds double, double* %457, i64 %459
store double %456, double* %460
%461 = load double*, double** %5
%462 = load i32, i32* %12
%463 = load i32, i32* %6
%464 = mul nsw i32 %462, %463
%465 = load i32, i32* %12
%466 = add nsw i32 %464, %465
%467 = sext i32 %466 to i64
%468 = getelementptr inbounds double, double* %461, i64 %467
store double 1.000000e+00, double* %468
store i32 0, i32* %11
br label %469
469: ; preds = %490, %447
%470 = load i32, i32* %11
%471 = load i32, i32* %9
%472 = icmp sle i32 %470, %471
br i1 %472, label %473, label %493
473: ; preds = %469
%474 = load double*, double** %5
%475 = load i32, i32* %12
%476 = load i32, i32* %6
%477 = mul nsw i32 %475, %476
%478 = load i32, i32* %11
%479 = add nsw i32 %477, %478
%480 = sext i32 %479 to i64
%481 = getelementptr inbounds double, double* %474, i64 %480
store double 0.000000e+00, double* %481
%482 = load double*, double** %5
%483 = load i32, i32* %11
%484 = load i32, i32* %6
%485 = mul nsw i32 %483, %484
%486 = load i32, i32* %12
%487 = add nsw i32 %485, %486
%488 = sext i32 %487 to i64
%489 = getelementptr inbounds double, double* %482, i64 %488
store double 0.000000e+00, double* %489
br label %490
490: ; preds = %473
%491 = load i32, i32* %11
%492 = add nsw i32 %491, 1
store i32 %492, i32* %11
br label %469
493: ; preds = %469
br label %494
494: ; preds = %493
%495 = load i32, i32* %12
%496 = add nsw i32 %495, 1
store i32 %496, i32* %12
br label %365
497: ; preds = %365
ret void
}

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