#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 tred2a(double *const a, const int n, double *const d, double *const 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 += fabs(a[i * n + k]);
      if (scale == 0.0)
        e[i] = a[i * n + l];
      else {
        double scale_inv = 1.0 / scale;
        for (k = 0; k <= l; k++) {
          a[i * n + k] *= scale_inv;
          h += a[i * n + k] * a[i * n + k];
        }
        f = a[i * n + l];
        g = (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 <= 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] != 0.0) {
      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):
<tred2a>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%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    1631 <tred2a+0x511>
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    15ee <tred2a+0x4ce>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     11b8 <tred2a+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 <tred2a+0x54>
movsd  -0x38(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    11f8 <tred2a+0xd8>
jp     11f8 <tred2a+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    15e9 <tred2a+0x4c9>
movsd  0xe00(%rip),%xmm0
divsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     1289 <tred2a+0x169>
movsd  -0x60(%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
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    1211 <tred2a+0xf1>
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     12e1 <tred2a+0x1c1>
movsd  -0x48(%rbp),%xmm0
call   1040 <sqrt@plt>
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x68(%rbp)
jmp    12f0 <tred2a+0x1d0>
movsd  -0x48(%rbp),%xmm0
call   1040 <sqrt@plt>
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%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
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     14ce <tred2a+0x3ae>
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     1417 <tred2a+0x2f7>
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    13bf <tred2a+0x29f>
jmp    141c <tred2a+0x2fc>
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     1474 <tred2a+0x354>
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    141c <tred2a+0x2fc>
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    1373 <tred2a+0x253>
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     15e4 <tred2a+0x4c4>
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     15d1 <tred2a+0x4b1>
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    1563 <tred2a+0x443>
jmp    15d6 <tred2a+0x4b6>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    14ed <tred2a+0x3cd>
jmp    15e9 <tred2a+0x4c9>
jmp    1611 <tred2a+0x4f1>
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 <tred2a+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    1837 <tred2a+0x717>
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    1688 <tred2a+0x568>
jp     1688 <tred2a+0x568>
jmp    1790 <tred2a+0x670>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     178b <tred2a+0x66b>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     1702 <tred2a+0x5e2>
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    16aa <tred2a+0x58a>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     1778 <tred2a+0x658>
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    1709 <tred2a+0x5e9>
jmp    177d <tred2a+0x65d>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    168f <tred2a+0x56f>
jmp    1790 <tred2a+0x670>
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  0x834(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     1824 <tred2a+0x704>
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    17d8 <tred2a+0x6b8>
jmp    1829 <tred2a+0x709>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    164e <tred2a+0x52e>
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<tred2a>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xc8,%rsp
mov    %rcx,%rbx
mov    %rdx,0x30(%rsp)
mov    %rdi,%r9
mov    %esi,%edi
mov    %rsi,0x48(%rsp)
cmp    $0x2,%esi
mov    %r9,0x10(%rsp)
mov    %rdi,0x18(%rsp)
jl     193a <tred2a+0x81a>
mov    0x48(%rsp),%rax
lea    -0x1(%rax),%ecx
lea    0x8(%r9),%rax
mov    %rax,0x58(%rsp)
lea    0x0(,%rdi,8),%rax
mov    %rax,0x50(%rsp)
lea    0x8(,%rdi,8),%rdx
mov    %rdx,0xc0(%rsp)
lea    -0x1(%rdi),%rdx
imul   %rdi,%rdx
lea    0x1(%rdx),%rsi
mov    %rsi,0xa0(%rsp)
mov    %rcx,%rsi
neg    %rsi
mov    %rsi,0x98(%rsp)
lea    (%r9,%rdx,8),%r14
add    $0x18,%r14
neg    %rax
mov    %rax,0xb0(%rsp)
lea    (%r9,%rdx,8),%r12
add    $0x8,%r12
lea    (%r9,%rdx,8),%r13
lea    0x10(%r9),%rax
mov    %rax,0x90(%rsp)
xor    %esi,%esi
mov    %rdx,0xa8(%rsp)
mov    %rdx,0x60(%rsp)
mov    %rdi,%rdx
mov    %rcx,%rax
mov    %rcx,0xb8(%rsp)
mov    %rcx,0x20(%rsp)
jmp    1249 <tred2a+0x129>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x68(%rsp),%r14
mov    0x78(%rsp),%rsi
mov    0x70(%rsp),%rcx
mov    0x40(%rsp),%rdx
mov    0x30(%rsp),%rax
movsd  %xmm9,(%rax,%rdx,8)
addq   $0xffffffffffffffff,0x20(%rsp)
add    $0x1,%rsi
mov    0xb0(%rsp),%rax
add    %rax,%r14
sub    %rdi,0x60(%rsp)
add    %rax,%r12
add    %rax,%r13
cmp    $0x2,%rcx
jle    193a <tred2a+0x81a>
lea    -0x1(%rdx),%rcx
mov    %rcx,%rax
imul   %rdi,%rax
mov    %rax,0x28(%rsp)
cmp    $0x2,%rdx
je     191d <tred2a+0x7fd>
mov    %rcx,0x40(%rsp)
mov    %rdx,0x70(%rsp)
mov    %rsi,0x78(%rsp)
not    %rsi
mov    0xb8(%rsp),%rax
mov    %rsi,0x38(%rsp)
add    %rsi,%rax
cmp    $0x3,%rax
jae    12a0 <tred2a+0x180>
xorpd  %xmm4,%xmm4
xor    %ebp,%ebp
jmp    133c <tred2a+0x21c>
cs nopw 0x0(%rax,%rax,1)
mov    0x20(%rsp),%r15
and    $0xfffffffffffffffc,%r15
xorps  %xmm4,%xmm4
xor    %ebp,%ebp
xchg   %ax,%ax
movsd  %xmm4,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  %xmm4,%xmm4
cvtsi2sd %rax,%xmm4
addsd  0x8(%rsp),%xmm4
add    $0x4,%rbp
cmp    %rbp,%r15
jne    12b0 <tred2a+0x190>
mov    %r14,0x68(%rsp)
testb  $0x3,0x20(%rsp)
je     139d <tred2a+0x27d>
mov    0x20(%rsp),%r15
and    $0x3,%r15d
add    0x60(%rsp),%rbp
mov    0x10(%rsp),%rax
lea    (%rax,%rbp,8),%rbp
xor    %r14d,%r14d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  %xmm4,0x8(%rsp)
movsd  0x0(%rbp,%r14,8),%xmm0
call   1030 <fabs@plt>
movsd  0x8(%rsp),%xmm4
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
addsd  %xmm0,%xmm4
add    $0x1,%r14
cmp    %r14,%r15
jne    1370 <tred2a+0x250>
mov    0x70(%rsp),%rcx
lea    -0x2(%rcx),%r15
ucomisd 0xc5a(%rip),%xmm4
mov    0x78(%rsp),%rsi
jne    13f0 <tred2a+0x2d0>
jp     13f0 <tred2a+0x2d0>
mov    0x28(%rsp),%rax
add    %r15,%rax
mov    0x10(%rsp),%r9
movsd  (%r9,%rax,8),%xmm0
mov    0x40(%rsp),%rdx
movsd  %xmm0,(%rbx,%rdx,8)
xorpd  %xmm9,%xmm9
mov    0x18(%rsp),%rdi
mov    0x68(%rsp),%r14
jmp    1214 <tred2a+0xf4>
nopl   0x0(%rax,%rax,1)
movsd  0xc08(%rip),%xmm0
divsd  %xmm4,%xmm0
mov    0x38(%rsp),%rax
cmp    0x98(%rsp),%rax
mov    0x10(%rsp),%r9
mov    0x18(%rsp),%rdi
jne    141e <tred2a+0x2fe>
xorpd  %xmm9,%xmm9
xor    %eax,%eax
jmp    146f <tred2a+0x34f>
mov    0x20(%rsp),%rcx
and    $0xfffffffffffffffe,%rcx
xorpd  %xmm9,%xmm9
xor    %eax,%eax
xchg   %ax,%ax
movsd  -0x8(%r12,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,-0x8(%r12,%rax,8)
mulsd  %xmm1,%xmm1
addsd  %xmm9,%xmm1
movsd  (%r12,%rax,8),%xmm9
mulsd  %xmm0,%xmm9
movsd  %xmm9,(%r12,%rax,8)
mulsd  %xmm9,%xmm9
addsd  %xmm1,%xmm9
add    $0x2,%rax
cmp    %rax,%rcx
jne    1430 <tred2a+0x310>
mov    %rsi,%r14
imul   %rdi,%r14
testb  $0x1,0x20(%rsp)
je     1497 <tred2a+0x377>
add    0x28(%rsp),%rax
mulsd  (%r9,%rax,8),%xmm0
movsd  %xmm0,(%r9,%rax,8)
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm9
mov    0xa8(%rsp),%rbp
sub    %r14,%rbp
mov    0x28(%rsp),%rax
lea    (%rax,%r15,1),%rcx
movsd  (%r9,%rcx,8),%xmm1
ucomisd 0xb4e(%rip),%xmm9
jb     14c6 <tred2a+0x3a6>
xorps  %xmm0,%xmm0
sqrtsd %xmm9,%xmm0
jmp    1516 <tred2a+0x3f6>
movapd %xmm9,%xmm0
movsd  %xmm9,0x38(%rsp)
movsd  %xmm4,0x8(%rsp)
mov    %rcx,0x88(%rsp)
movsd  %xmm1,0x80(%rsp)
call   1040 <sqrt@plt>
movsd  0x80(%rsp),%xmm1
mov    0x88(%rsp),%rcx
movsd  0x8(%rsp),%xmm4
movsd  0x38(%rsp),%xmm9
mov    0x18(%rsp),%rdi
mov    0x10(%rsp),%r9
lea    (%r9,%rbp,8),%rax
mov    %rax,0x8(%rsp)
mov    0xa0(%rsp),%rax
sub    %r14,%rax
mov    %rax,0x38(%rsp)
xorpd  %xmm8,%xmm8
xorpd  %xmm2,%xmm2
cmpnlesd %xmm1,%xmm2
movapd %xmm2,%xmm3
andpd  %xmm0,%xmm3
xorpd  0xac3(%rip),%xmm0
andnpd %xmm0,%xmm2
orpd   %xmm3,%xmm2
mulsd  %xmm2,%xmm4
mov    0x40(%rsp),%rax
movsd  %xmm4,(%rbx,%rax,8)
movapd %xmm1,%xmm0
mulsd  %xmm2,%xmm0
subsd  %xmm0,%xmm9
subsd  %xmm2,%xmm1
movsd  %xmm1,(%r9,%rcx,8)
mov    $0x1,%r8d
mov    $0x1,%r11d
mov    0x58(%rsp),%rsi
xor    %ebp,%ebp
mov    0x50(%rsp),%r14
jmp    15cf <tred2a+0x4af>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
divsd  %xmm9,%xmm0
movsd  %xmm0,(%rbx,%rbp,8)
mulsd  (%r9,%r10,8),%xmm0
addsd  %xmm0,%xmm8
add    $0x1,%rbp
add    $0x1,%r8
add    %r14,%rsi
add    $0x1,%r11d
cmp    0x20(%rsp),%rbp
je     16c0 <tred2a+0x5a0>
mov    0x28(%rsp),%rax
lea    (%rax,%rbp,1),%r10
movsd  (%r9,%r10,8),%xmm0
divsd  %xmm9,%xmm0
mov    %rbp,%rax
imul   %rdi,%rax
mov    0x40(%rsp),%rcx
add    %rax,%rcx
movsd  %xmm0,(%r9,%rcx,8)
cmp    $0x1,%r8d
jne    1610 <tred2a+0x4f0>
xor    %ecx,%ecx
xorpd  %xmm0,%xmm0
jmp    165d <tred2a+0x53d>
cs nopw 0x0(%rax,%rax,1)
mov    %r11d,%edx
mov    %r11d,%ecx
and    $0x1,%ecx
sub    %rcx,%rdx
xorpd  %xmm2,%xmm2
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  -0x8(%rsi,%rcx,8),%xmm3
movsd  (%rsi,%rcx,8),%xmm0
mulsd  -0x8(%r12,%rcx,8),%xmm3
mulsd  (%r12,%rcx,8),%xmm0
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm0
add    $0x2,%rcx
movapd %xmm0,%xmm2
cmp    %rcx,%rdx
jne    1630 <tred2a+0x510>
test   $0x1,%r8b
je     167b <tred2a+0x55b>
add    %rcx,%rax
movsd  (%r9,%rax,8),%xmm2
add    0x28(%rsp),%rcx
mulsd  (%r9,%rcx,8),%xmm2
addsd  %xmm2,%xmm0
cmp    %r15,%rbp
jge    15a0 <tred2a+0x480>
movslq %r11d,%rcx
mov    %rdi,%rdx
imul   %rcx,%rdx
add    %rbp,%rdx
add    $0xffffffffffffffff,%rcx
lea    (%r9,%rdx,8),%rdx
nopl   0x0(%rax)
movsd  (%rdx),%xmm2
mulsd  0x8(%r13,%rcx,8),%xmm2
addsd  %xmm2,%xmm0
add    $0x1,%rcx
add    %r14,%rdx
cmp    %r15,%rcx
jl     16a0 <tred2a+0x580>
jmp    15a0 <tred2a+0x480>
movapd %xmm9,%xmm0
addsd  %xmm9,%xmm0
xorpd  0x93d(%rip),%xmm8
divsd  %xmm0,%xmm8
mov    $0x1,%edx
mov    0x58(%rsp),%rsi
mov    0x90(%rsp),%r10
xor    %r8d,%r8d
jmp    1705 <tred2a+0x5e5>
nop
add    $0x1,%rdx
add    %r14,%r10
add    %r14,%rsi
cmp    0x20(%rsp),%r8
je     1200 <tred2a+0xe0>
mov    %r8,%rax
add    $0x1,%r8
mov    %rax,%r11
imul   %rdi,%r11
mov    0x28(%rsp),%rcx
add    %rax,%rcx
movsd  (%r9,%rcx,8),%xmm0
movapd %xmm8,%xmm2
mulsd  %xmm0,%xmm2
addsd  (%rbx,%rax,8),%xmm2
movsd  %xmm2,(%rbx,%rax,8)
cmp    $0x3,%rax
jae    1750 <tred2a+0x630>
xor    %r15d,%r15d
jmp    1870 <tred2a+0x750>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r8,%rdi
lea    (%r9,%r11,8),%r14
mov    0xc0(%rsp),%rbp
imul   %rax,%rbp
add    0x58(%rsp),%rbp
mov    0x38(%rsp),%rcx
add    %rax,%rcx
lea    (%r9,%rcx,8),%r15
lea    (%rbx,%rax,8),%rcx
add    $0x8,%rcx
cmp    %rcx,%r14
setb   %r8b
cmp    %rbx,%rbp
seta   %r9b
cmp    %r15,%r14
setb   %cl
cmp    0x8(%rsp),%rbp
seta   %bpl
test   %r9b,%r8b
jne    1857 <tred2a+0x737>
mov    $0x0,%r15d
and    %bpl,%cl
mov    0x10(%rsp),%r9
mov    0x18(%rsp),%rcx
mov    0x50(%rsp),%r14
mov    %rdi,%r8
mov    %rcx,%rdi
jne    1870 <tred2a+0x750>
mov    %rdx,%rcx
and    $0xfffffffffffffffc,%rcx
mov    %r8,%r15
and    $0xfffffffffffffffc,%r15
movapd %xmm2,%xmm3
unpcklpd %xmm2,%xmm3
movapd %xmm0,%xmm4
unpcklpd %xmm0,%xmm4
xor    %ebp,%ebp
cs nopw 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),%xmm1
mulpd  %xmm3,%xmm7
mulpd  %xmm3,%xmm1
mulpd  %xmm4,%xmm5
addpd  %xmm7,%xmm5
mulpd  %xmm4,%xmm6
addpd  %xmm1,%xmm6
movupd -0x10(%r10,%rbp,8),%xmm1
subpd  %xmm5,%xmm1
movupd (%r10,%rbp,8),%xmm5
subpd  %xmm6,%xmm5
movupd %xmm1,-0x10(%r10,%rbp,8)
movupd %xmm5,(%r10,%rbp,8)
add    $0x4,%rbp
cmp    %rbp,%rcx
jne    17f0 <tred2a+0x6d0>
cmp    %r15,%r8
je     16f0 <tred2a+0x5d0>
jmp    1870 <tred2a+0x750>
xor    %r15d,%r15d
mov    0x10(%rsp),%r9
mov    0x18(%rsp),%rcx
mov    0x50(%rsp),%r14
mov    %rdi,%r8
mov    %rcx,%rdi
nop
mov    %r15,%rcx
test   $0x1,%dl
je     18b2 <tred2a+0x792>
mov    0x28(%rsp),%rcx
add    %r15,%rcx
movsd  (%r9,%rcx,8),%xmm1
mulsd  %xmm2,%xmm1
movsd  (%rbx,%r15,8),%xmm3
mulsd  %xmm0,%xmm3
addsd  %xmm1,%xmm3
add    %r15,%r11
movsd  (%r9,%r11,8),%xmm1
subsd  %xmm3,%xmm1
movsd  %xmm1,(%r9,%r11,8)
mov    %r15,%rcx
or     $0x1,%rcx
cmp    %r15,%rax
je     16f0 <tred2a+0x5d0>
nopl   0x0(%rax,%rax,1)
movsd  0x0(%r13,%rcx,8),%xmm1
mulsd  %xmm2,%xmm1
movsd  (%rbx,%rcx,8),%xmm3
mulsd  %xmm0,%xmm3
addsd  %xmm1,%xmm3
movsd  -0x8(%rsi,%rcx,8),%xmm1
subsd  %xmm3,%xmm1
movsd  (%rsi,%rcx,8),%xmm3
movsd  %xmm1,-0x8(%rsi,%rcx,8)
movsd  0x8(%r13,%rcx,8),%xmm1
mulsd  %xmm2,%xmm1
movsd  0x8(%rbx,%rcx,8),%xmm4
mulsd  %xmm0,%xmm4
addsd  %xmm1,%xmm4
subsd  %xmm4,%xmm3
movsd  %xmm3,(%rsi,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rdx
jne    18c0 <tred2a+0x7a0>
jmp    16f0 <tred2a+0x5d0>
mov    0x28(%rsp),%rax
movsd  (%r9,%rax,8),%xmm0
movsd  %xmm0,(%rbx,%rcx,8)
mov    0x30(%rsp),%rax
movq   $0x0,(%rax,%rcx,8)
mov    0x30(%rsp),%rax
movq   $0x0,(%rax)
movq   $0x0,(%rbx)
cmpl   $0x0,0x48(%rsp)
jle    1bde <tred2a+0xabe>
mov    %rdi,%rsi
mov    0x10(%rsp),%r12
lea    0x8(%r12),%rax
lea    0x0(,%rdi,8),%r14
mov    %rdi,%rdx
shl    $0x4,%rdx
lea    (%r12,%rdi,8),%r9
xor    %r11d,%r11d
xorpd  %xmm0,%xmm0
movapd 0x689(%rip),%xmm1
mov    %r9,%r13
jmp    19ad <tred2a+0x88d>
nopl   0x0(%rax)
add    $0x1,%r11
add    %r14,%rax
add    $0x8,%r13
add    $0x8,%r12
mov    0x18(%rsp),%rsi
cmp    %rsi,%r11
je     1bde <tred2a+0xabe>
mov    %r11,%rdi
and    $0xfffffffffffffffe,%rdi
mov    0x30(%rsp),%rcx
movsd  (%rcx,%r11,8),%xmm2
mov    %r11,%r10
imul   %rsi,%r10
ucomisd %xmm0,%xmm2
jne    19d2 <tred2a+0x8b2>
jnp    1b20 <tred2a+0xa00>
test   %r11,%r11
je     1b20 <tred2a+0xa00>
mov    %r9,%rbp
mov    0x10(%rsp),%rsi
xor    %r15d,%r15d
jmp    1a05 <tred2a+0x8e5>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r15
add    $0x8,%rsi
add    $0x8,%rbp
cmp    %r11,%r15
je     1b20 <tred2a+0xa00>
cmp    $0x1,%r11
jne    1a20 <tred2a+0x900>
xorpd  %xmm2,%xmm2
xor    %ebx,%ebx
jmp    1a5d <tred2a+0x93d>
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    1a30 <tred2a+0x910>
test   $0x1,%r11b
je     1a85 <tred2a+0x965>
lea    (%rbx,%r10,1),%rcx
mov    0x10(%rsp),%r8
movsd  (%r8,%rcx,8),%xmm3
imul   0x18(%rsp),%rbx
add    %r15,%rbx
mulsd  (%r8,%rbx,8),%xmm3
addsd  %xmm3,%xmm2
xorpd  %xmm1,%xmm2
cmp    $0x1,%r11
jne    1aa0 <tred2a+0x980>
xor    %ebx,%ebx
jmp    1ae7 <tred2a+0x9c7>
cs nopw 0x0(%rax,%rax,1)
nopl   (%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    1ab0 <tred2a+0x990>
test   $0x1,%r11b
je     19f0 <tred2a+0x8d0>
imul   0x18(%rsp),%rbx
lea    (%rbx,%r11,1),%rcx
mov    0x10(%rsp),%r8
mulsd  (%r8,%rcx,8),%xmm2
add    %r15,%rbx
addsd  (%r8,%rbx,8),%xmm2
movsd  %xmm2,(%r8,%rbx,8)
jmp    19f0 <tred2a+0x8d0>
nopw   0x0(%rax,%rax,1)
mov    %r11d,%ecx
imul   0x48(%rsp),%ecx
movslq %ecx,%rcx
add    %r11,%rcx
mov    0x10(%rsp),%rbp
movsd  0x0(%rbp,%rcx,8),%xmm2
mov    0x30(%rsp),%rsi
movsd  %xmm2,(%rsi,%r11,8)
movabs $0x3ff0000000000000,%rsi
mov    %rsi,0x0(%rbp,%rcx,8)
test   %r11,%r11
je     1990 <tred2a+0x870>
cmp    $0x1,%r11
jne    1b70 <tred2a+0xa50>
xor    %ecx,%ecx
jmp    1bae <tred2a+0xa8e>
cs nopw 0x0(%rax,%rax,1)
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    1b80 <tred2a+0xa60>
test   $0x1,%r11b
je     1990 <tred2a+0x870>
add    %rcx,%r10
mov    0x10(%rsp),%rsi
movq   $0x0,(%rsi,%r10,8)
imul   0x18(%rsp),%rcx
add    %r11,%rcx
movq   $0x0,(%rsi,%rcx,8)
jmp    1990 <tred2a+0x870>
add    $0xc8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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