#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 reduce(const int n, double *__restrict__ a, double *__restrict__ d,
            double *__restrict__ e) {
  register int i, j, k;
  register double scale, h, f, g, hh;
  int l, iz, jk;
  for (i = n; i--;) {
    l = i - 1;
    iz = i * (i + 1) / 2 - 1;
    h = scale = 0.0;
    for (k = 0; k < i; k++) {
      d[k] = a[++iz];
      scale += fabs(d[k]);
    }
    if (scale == 0.0 || !i) {
      e[i] = 0.0;
      d[i] = a[++iz];
      a[iz] = 0.0;
      continue;
    }
    f = 1.0 / scale;
    for (k = 0; k <= l; k++) {
      d[k] *= f;
      h += d[k] * d[k];
    }
    f = d[l];
    g = -sqrt(h);
    if (f < 0)
      g = -g;
    e[i] = scale * g;
    h -= f * g;
    d[l] = f - g;
    a[iz] = scale * d[l];
    if (i == 1) {
      d[i] = a[++iz];
      a[iz] = scale * sqrt(h);
      continue;
    }
    jk = 0;
    for (j = 0; j <= l; j++) {
      f = d[j];
      g = 0.0;
      for (k = 0; k < j; k++) {
        g += a[jk] * d[k];
        e[k] += a[jk] * f;
        jk++;
      }
      e[j] = g + a[jk] * f;
      jk++;
    }
    f = 0.0;
    for (j = 0; j < i; j++) {
      e[j] /= h;
      f += e[j] * d[j];
    }
    hh = f / 2.0 / h;
    for (j = 0; j < i; j++) {
      e[j] -= hh * d[j];
    }
    jk = 0;
    for (j = 0; j <= l; j++) {
      f = d[j];
      g = e[j];
      for (k = 0; k <= j; k++) {
        a[jk] -= (f * e[k] + g * d[k]);
        jk++;
      }
    }
    d[i] = a[++iz];
    a[iz] = scale * sqrt(h);
  }
  return;
}


x86 assembly (clang, -O0):
<reduce>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    -0x4(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x24(%rbp)
cmp    $0x0,%eax
je     170d <reduce+0x5ed>
mov    -0x24(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
sub    $0x1,%eax
mov    %eax,-0x60(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    11eb <reduce+0xcb>
mov    -0x10(%rbp),%rax
mov    -0x60(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x60(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1030 <fabs@plt>
cvtsi2sd %rax,%xmm0
addsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    118e <reduce+0x6e>
movsd  -0x38(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1208 <reduce+0xe8>
jp     1208 <reduce+0xe8>
jmp    1212 <reduce+0xf2>
cmpl   $0x0,-0x24(%rbp)
jne    1259 <reduce+0x139>
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
mov    -0x60(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x60(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
movslq -0x60(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1140 <reduce+0x20>
movsd  0xd9f(%rip),%xmm0
divsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x5c(%rbp),%eax
jg     12cf <reduce+0x1af>
movsd  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x40(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1272 <reduce+0x152>
mov    -0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x40(%rbp),%xmm0
call   1040 <sqrt@plt>
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x50(%rbp)
xorps  %xmm0,%xmm0
ucomisd -0x48(%rbp),%xmm0
jbe    1336 <reduce+0x216>
movsd  -0x50(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x38(%rbp),%xmm0
mulsd  -0x50(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x48(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm2
movsd  -0x40(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x48(%rbp),%xmm0
subsd  -0x50(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x38(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x60(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x1,-0x24(%rbp)
jne    1414 <reduce+0x2f4>
mov    -0x10(%rbp),%rax
mov    -0x60(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x60(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x40(%rbp),%xmm0
call   1040 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0x70(%rbp),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x60(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1140 <reduce+0x20>
movl   $0x0,-0x64(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x5c(%rbp),%eax
jg     150d <reduce+0x3ed>
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    14ca <reduce+0x3aa>
mov    -0x10(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x48(%rbp),%xmm2
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    144f <reduce+0x32f>
movsd  -0x50(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x48(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1422 <reduce+0x302>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    157d <reduce+0x45d>
movsd  -0x40(%rbp),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -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    151c <reduce+0x3fc>
movsd  -0x48(%rbp),%xmm0
movsd  0xa7e(%rip),%xmm1
divsd  %xmm1,%xmm0
divsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    15fc <reduce+0x4dc>
movsd  -0x58(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    159f <reduce+0x47f>
movl   $0x0,-0x64(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x5c(%rbp),%eax
jg     16b9 <reduce+0x599>
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jg     16a6 <reduce+0x586>
movsd  -0x48(%rbp),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x50(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1641 <reduce+0x521>
jmp    16ab <reduce+0x58b>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    160a <reduce+0x4ea>
mov    -0x10(%rbp),%rax
mov    -0x60(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x60(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x40(%rbp),%xmm0
call   1040 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0x78(%rbp),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x60(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1140 <reduce+0x20>
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<reduce>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
test   %edi,%edi
je     194b <reduce+0x82b>
mov    %rcx,%rbx
mov    %rdx,%r14
mov    %rsi,%r13
mov    %edi,%r15d
lea    -0x1(%r15),%eax
mov    %rax,%rcx
neg    %rcx
mov    %rcx,0x60(%rsp)
lea    0x8(%rsi),%rcx
mov    %rcx,0x68(%rsp)
lea    -0x4(%rax),%r11
lea    0x10(%rsi),%rcx
mov    %rcx,0x70(%rsp)
xor    %edx,%edx
xorpd  %xmm8,%xmm8
mov    %rax,0x30(%rsp)
mov    %rax,%rsi
mov    %r13,0x58(%rsp)
jmp    11bc <reduce+0x9c>
nopl   (%rax)
add    $0xffffffff,%ecx
movslq %r15d,%rax
movq   $0x0,(%rbx,%rax,8)
movslq %ecx,%rcx
movsd  0x8(%r13,%rcx,8),%xmm0
movsd  %xmm0,(%r14,%rax,8)
movq   $0x0,0x8(%r13,%rcx,8)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rsi
add    $0xffffffffffffffff,%r11
test   %r15d,%r15d
je     194b <reduce+0x82b>
mov    %r15d,%r9d
lea    -0x1(%r9),%r15d
mov    %r15d,%eax
imul   %r9d,%eax
mov    %eax,%ecx
shr    $0x1f,%ecx
add    %eax,%ecx
sar    %ecx
cmp    $0x2,%r9d
jl     1180 <reduce+0x60>
mov    0x30(%rsp),%r10
sub    %rdx,%r10
mov    %rdx,%rax
not    %rax
add    $0xffffffff,%ecx
movslq %ecx,%rcx
cmp    0x60(%rsp),%rax
mov    %r11,0x20(%rsp)
mov    %rdx,0x8(%rsp)
mov    %r9,0x38(%rsp)
mov    %r15,0x40(%rsp)
mov    %rsi,0x10(%rsp)
jne    1230 <reduce+0x110>
xorpd  %xmm9,%xmm9
xor    %ebp,%ebp
test   $0x1,%r10b
jne    12f6 <reduce+0x1d6>
jmp    135a <reduce+0x23a>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r10,0x28(%rsp)
mov    %rsi,%r12
and    $0xfffffffffffffffe,%r12
neg    %r12
mov    %rcx,0x18(%rsp)
lea    0x8(%r13,%rcx,8),%r13
xorps  %xmm9,%xmm9
mov    $0x8,%r15d
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
movsd  %xmm9,(%rsp)
movsd  -0x8(%r13,%r15,1),%xmm0
movsd  %xmm0,-0x8(%r14,%r15,1)
call   1030 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
addsd  (%rsp),%xmm0
movsd  %xmm0,(%rsp)
movsd  0x0(%r13,%r15,1),%xmm0
movsd  %xmm0,(%r14,%r15,1)
call   1030 <fabs@plt>
xorps  %xmm9,%xmm9
cvtsi2sd %rax,%xmm9
addsd  (%rsp),%xmm9
add    $0x10,%r15
add    $0xfffffffffffffffe,%rbp
cmp    %rbp,%r12
jne    1260 <reduce+0x140>
mov    0x18(%rsp),%rcx
sub    %rbp,%rcx
neg    %rbp
lea    -0x1(%rcx),%rdi
mov    0x58(%rsp),%r13
mov    0x40(%rsp),%r15
mov    0x20(%rsp),%r11
mov    0x8(%rsp),%rdx
xorpd  %xmm8,%xmm8
mov    0x10(%rsp),%rsi
mov    0x38(%rsp),%r9
mov    0x28(%rsp),%r10
test   $0x1,%r10b
je     135a <reduce+0x23a>
lea    0x1(%rcx),%rax
mov    %rax,0x18(%rsp)
movsd  0x8(%r13,%rcx,8),%xmm0
movsd  %xmm0,(%r14,%rbp,8)
mov    %rsi,%rbp
movsd  %xmm9,(%rsp)
mov    %r10,%r12
mov    %rcx,%r15
call   1030 <fabs@plt>
mov    %r12,%r10
mov    0x38(%rsp),%r9
movsd  (%rsp),%xmm9
mov    %rbp,%rsi
xorpd  %xmm8,%xmm8
mov    0x8(%rsp),%rdx
mov    0x20(%rsp),%r11
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
addsd  %xmm0,%xmm9
mov    %r15,%rdi
mov    0x18(%rsp),%rcx
mov    0x40(%rsp),%r15
ucomisd %xmm8,%xmm9
jne    1367 <reduce+0x247>
jnp    1183 <reduce+0x63>
test   %r15d,%r15d
je     1183 <reduce+0x63>
mov    %esi,%r12d
and    $0xfffffffe,%r12d
lea    -0x2(%r9),%eax
xorpd  %xmm10,%xmm10
cmp    $0x2,%r9d
jl     140c <reduce+0x2ec>
mov    %rcx,%rbp
mov    0x30(%rsp),%rcx
sub    %edx,%ecx
movsd  0xc64(%rip),%xmm0
divsd  %xmm9,%xmm0
xorpd  %xmm10,%xmm10
xor    %edx,%edx
cmp    $0x1,%ecx
je     13ef <reduce+0x2cf>
nopl   (%rax)
movsd  (%r14,%rdx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r14,%rdx,8)
mulsd  %xmm1,%xmm1
addsd  %xmm10,%xmm1
movsd  0x8(%r14,%rdx,8),%xmm10
mulsd  %xmm0,%xmm10
movsd  %xmm10,0x8(%r14,%rdx,8)
mulsd  %xmm10,%xmm10
addsd  %xmm1,%xmm10
add    $0x2,%rdx
cmp    %rdx,%r12
jne    13b0 <reduce+0x290>
test   $0x1,%cl
mov    %rbp,%rcx
je     140c <reduce+0x2ec>
mulsd  (%r14,%rdx,8),%xmm0
movsd  %xmm0,(%r14,%rdx,8)
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm10
movslq %eax,%rbp
movsd  (%r14,%rbp,8),%xmm3
ucomisd %xmm8,%xmm10
movsd  %xmm9,(%rsp)
mov    %rdi,0x28(%rsp)
jb     1431 <reduce+0x311>
xorps  %xmm0,%xmm0
sqrtsd %xmm10,%xmm0
jmp    147f <reduce+0x35f>
movapd %xmm10,%xmm0
movsd  %xmm10,0x50(%rsp)
mov    %r10,%r15
mov    %rcx,0x18(%rsp)
movsd  %xmm3,0x48(%rsp)
call   1040 <sqrt@plt>
movsd  0x48(%rsp),%xmm3
mov    0x18(%rsp),%rcx
mov    %r15,%r10
mov    0x40(%rsp),%r15
movsd  0x50(%rsp),%xmm10
mov    0x38(%rsp),%r9
movsd  (%rsp),%xmm9
xorpd  %xmm8,%xmm8
mov    0x20(%rsp),%r11
movapd %xmm3,%xmm1
cmpltsd %xmm8,%xmm1
movapd %xmm1,%xmm2
andpd  %xmm0,%xmm2
xorpd  0xb77(%rip),%xmm0
andnpd %xmm0,%xmm1
orpd   %xmm2,%xmm1
movapd %xmm9,%xmm0
mulsd  %xmm1,%xmm0
movslq %r15d,%r8
movsd  %xmm0,(%rbx,%r8,8)
movapd %xmm3,%xmm0
mulsd  %xmm1,%xmm0
subsd  %xmm0,%xmm10
subsd  %xmm1,%xmm3
movsd  %xmm3,(%r14,%rbp,8)
mulsd  %xmm9,%xmm3
movslq %ecx,%rax
movsd  %xmm3,0x0(%r13,%rax,8)
cmp    $0x1,%r15d
je     17c3 <reduce+0x6a3>
cmp    $0x2,%r9d
jge    1510 <reduce+0x3f0>
cmp    $0x2,%r9d
jl     17bd <reduce+0x69d>
mov    0x30(%rsp),%rax
sub    0x8(%rsp),%eax
cmp    $0x1,%eax
jne    1618 <reduce+0x4f8>
xorpd  %xmm0,%xmm0
xor    %ecx,%ecx
jmp    1662 <reduce+0x542>
mov    %r15d,%ecx
xor    %edx,%edx
xor    %esi,%esi
jmp    1543 <reduce+0x423>
nopl   0x0(%rax)
xorpd  %xmm1,%xmm1
movslq %esi,%rsi
mulsd  0x0(%r13,%rsi,8),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rbx,%rdx,8)
add    $0x1,%esi
add    $0x1,%rdx
cmp    %rcx,%rdx
je     14e9 <reduce+0x3c9>
movsd  (%r14,%rdx,8),%xmm0
test   %rdx,%rdx
je     1520 <reduce+0x400>
movslq %esi,%rsi
cmp    $0x1,%rdx
jne    1570 <reduce+0x450>
xorpd  %xmm1,%xmm1
xor    %eax,%eax
test   $0x1,%dl
je     1524 <reduce+0x404>
jmp    15ec <reduce+0x4cc>
nopw   0x0(%rax,%rax,1)
mov    %rdx,%rdi
and    $0xfffffffffffffffe,%rdi
mov    0x68(%rsp),%rax
lea    (%rax,%rsi,8),%rbp
xorpd  %xmm1,%xmm1
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
movsd  -0x8(%rbp,%rax,8),%xmm2
movsd  (%r14,%rax,8),%xmm3
mulsd  %xmm2,%xmm3
mulsd  %xmm0,%xmm2
addsd  (%rbx,%rax,8),%xmm2
addsd  %xmm1,%xmm3
movsd  %xmm2,(%rbx,%rax,8)
movsd  0x0(%rbp,%rax,8),%xmm2
movsd  0x8(%r14,%rax,8),%xmm1
mulsd  %xmm2,%xmm1
mulsd  %xmm0,%xmm2
addsd  0x8(%rbx,%rax,8),%xmm2
addsd  %xmm3,%xmm1
movsd  %xmm2,0x8(%rbx,%rax,8)
add    $0x2,%rax
cmp    %rax,%rdi
jne    1590 <reduce+0x470>
add    %rax,%rsi
test   $0x1,%dl
je     1524 <reduce+0x404>
movsd  0x0(%r13,%rsi,8),%xmm2
movsd  (%r14,%rax,8),%xmm3
mulsd  %xmm2,%xmm3
addsd  %xmm3,%xmm1
mulsd  %xmm0,%xmm2
addsd  (%rbx,%rax,8),%xmm2
movsd  %xmm2,(%rbx,%rax,8)
add    $0x1,%rsi
jmp    1524 <reduce+0x404>
xorpd  %xmm1,%xmm1
xor    %ecx,%ecx
xchg   %ax,%ax
movsd  (%rbx,%rcx,8),%xmm2
movsd  0x8(%rbx,%rcx,8),%xmm0
divsd  %xmm10,%xmm2
movsd  %xmm2,(%rbx,%rcx,8)
mulsd  (%r14,%rcx,8),%xmm2
divsd  %xmm10,%xmm0
movsd  %xmm0,0x8(%rbx,%rcx,8)
mulsd  0x8(%r14,%rcx,8),%xmm0
addsd  %xmm1,%xmm2
addsd  %xmm2,%xmm0
add    $0x2,%rcx
movapd %xmm0,%xmm1
cmp    %rcx,%r12
jne    1620 <reduce+0x500>
test   $0x1,%al
je     167f <reduce+0x55f>
movsd  (%rbx,%rcx,8),%xmm1
divsd  %xmm10,%xmm1
movsd  %xmm1,(%rbx,%rcx,8)
mulsd  (%r14,%rcx,8),%xmm1
addsd  %xmm1,%xmm0
cmp    $0x2,%r9d
jl     17bd <reduce+0x69d>
mulsd  0x977(%rip),%xmm0
divsd  %xmm10,%xmm0
cmp    $0x4,%r10
jae    16a3 <reduce+0x583>
xor    %edx,%edx
jmp    1796 <reduce+0x676>
lea    -0x4(%r10),%rcx
mov    %rcx,%rax
shr    $0x2,%rax
add    $0x1,%rax
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmp    $0x4,%rcx
jae    16c7 <reduce+0x5a7>
xor    %ecx,%ecx
jmp    1753 <reduce+0x633>
mov    %r11,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
and    $0xfffffffffffffffe,%rdx
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movupd (%r14,%rcx,8),%xmm2
movupd 0x10(%r14,%rcx,8),%xmm3
mulpd  %xmm1,%xmm2
movupd (%rbx,%rcx,8),%xmm4
addpd  %xmm2,%xmm4
movupd 0x10(%rbx,%rcx,8),%xmm2
movupd 0x20(%rbx,%rcx,8),%xmm5
movupd 0x30(%rbx,%rcx,8),%xmm6
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm4,(%rbx,%rcx,8)
movupd %xmm3,0x10(%rbx,%rcx,8)
movupd 0x20(%r14,%rcx,8),%xmm2
movupd 0x30(%r14,%rcx,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm5,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm6,%xmm3
movupd %xmm2,0x20(%rbx,%rcx,8)
movupd %xmm3,0x30(%rbx,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rdx
jne    16e0 <reduce+0x5c0>
mov    %r10,%rdx
and    $0xfffffffffffffffc,%rdx
test   $0x1,%al
je     1791 <reduce+0x671>
movupd (%r14,%rcx,8),%xmm2
movupd 0x10(%r14,%rcx,8),%xmm3
movupd (%rbx,%rcx,8),%xmm4
movupd 0x10(%rbx,%rcx,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,(%rbx,%rcx,8)
movupd %xmm3,0x10(%rbx,%rcx,8)
cmp    %rdx,%r10
je     17bd <reduce+0x69d>
mov    0x10(%rsp),%eax
nopw   0x0(%rax,%rax,1)
movsd  (%r14,%rdx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rbx,%rdx,8),%xmm1
movsd  %xmm1,(%rbx,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%rax
jne    17a0 <reduce+0x680>
cmp    $0x2,%r9d
jge    1837 <reduce+0x717>
mov    0x28(%rsp),%rcx
shl    $0x20,%rcx
movabs $0x200000000,%rax
add    %rax,%rcx
mov    %rcx,%rbp
sar    $0x20,%rbp
sar    $0x1d,%rcx
movsd  0x0(%r13,%rcx,1),%xmm0
movsd  %xmm0,(%r14,%r8,8)
ucomisd %xmm8,%xmm10
jb     1802 <reduce+0x6e2>
xorps  %xmm0,%xmm0
sqrtsd %xmm10,%xmm0
jmp    181c <reduce+0x6fc>
movapd %xmm10,%xmm0
call   1040 <sqrt@plt>
movsd  (%rsp),%xmm9
xorpd  %xmm8,%xmm8
mov    0x20(%rsp),%r11
mov    0x8(%rsp),%rdx
mov    0x10(%rsp),%rsi
mulsd  %xmm0,%xmm9
movsd  %xmm9,0x0(%r13,%rbp,8)
jmp    11a7 <reduce+0x87>
mov    %r15d,%r9d
mov    $0x1,%ebp
xor    %r10d,%r10d
xor    %esi,%esi
jmp    185d <reduce+0x73d>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rbp
cmp    %r9,%r10
je     17c3 <reduce+0x6a3>
mov    %r10,%rax
movsd  (%r14,%r10,8),%xmm0
movsd  (%rbx,%r10,8),%xmm1
add    $0x1,%r10
movslq %esi,%rsi
cmp    $0x3,%rax
jae    1880 <reduce+0x760>
xor    %edi,%edi
jmp    1910 <reduce+0x7f0>
mov    %rbp,%rdx
and    $0xfffffffffffffffc,%rdx
mov    %r10,%rdi
and    $0xfffffffffffffffc,%rdi
movapd %xmm1,%xmm2
unpcklpd %xmm1,%xmm2
movapd %xmm0,%xmm3
unpcklpd %xmm0,%xmm3
mov    0x70(%rsp),%rax
lea    (%rax,%rsi,8),%rcx
add    %rdi,%rsi
xor    %eax,%eax
nopl   0x0(%rax)
movupd (%rbx,%rax,8),%xmm4
movupd 0x10(%rbx,%rax,8),%xmm5
movupd (%r14,%rax,8),%xmm6
movupd 0x10(%r14,%rax,8),%xmm7
mulpd  %xmm2,%xmm6
mulpd  %xmm2,%xmm7
mulpd  %xmm3,%xmm4
addpd  %xmm6,%xmm4
mulpd  %xmm3,%xmm5
addpd  %xmm7,%xmm5
movupd -0x10(%rcx,%rax,8),%xmm6
subpd  %xmm4,%xmm6
movupd (%rcx,%rax,8),%xmm4
subpd  %xmm5,%xmm4
movupd %xmm6,-0x10(%rcx,%rax,8)
movupd %xmm4,(%rcx,%rax,8)
add    $0x4,%rax
cmp    %rax,%rdx
jne    18b0 <reduce+0x790>
cmp    %rdi,%r10
je     1850 <reduce+0x730>
movsd  (%r14,%rdi,8),%xmm2
mulsd  %xmm1,%xmm2
movsd  (%rbx,%rdi,8),%xmm3
mulsd  %xmm0,%xmm3
addsd  %xmm2,%xmm3
movsd  0x0(%r13,%rsi,8),%xmm2
subsd  %xmm3,%xmm2
movsd  %xmm2,0x0(%r13,%rsi,8)
add    $0x1,%rsi
add    $0x1,%rdi
cmp    %rdi,%rbp
jne    1910 <reduce+0x7f0>
jmp    1850 <reduce+0x730>
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @reduce(i32 %0, double* noalias %1, double* noalias %2, double* noalias %3) {
%5 = alloca i32
%6 = alloca double*
%7 = alloca double*
%8 = alloca double*
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca double
%13 = alloca double
%14 = alloca double
%15 = alloca double
%16 = alloca double
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
store i32 %0, i32* %5
store double* %1, double** %6
store double* %2, double** %7
store double* %3, double** %8
%20 = load i32, i32* %5
store i32 %20, i32* %9
br label %21
21: ; preds = %349, %163, %67, %4
%22 = load i32, i32* %9
%23 = add nsw i32 %22, -1
store i32 %23, i32* %9
%24 = icmp ne i32 %22, 0
br i1 %24, label %25, label %368
25: ; preds = %21
%26 = load i32, i32* %9
%27 = sub nsw i32 %26, 1
store i32 %27, i32* %17
%28 = load i32, i32* %9
%29 = load i32, i32* %9
%30 = add nsw i32 %29, 1
%31 = mul nsw i32 %28, %30
%32 = sdiv i32 %31, 2
%33 = sub nsw i32 %32, 1
store i32 %33, i32* %18
store double 0.000000e+00, double* %12
store double 0.000000e+00, double* %13
store i32 0, i32* %11
br label %34
34: ; preds = %58, %25
%35 = load i32, i32* %11
%36 = load i32, i32* %9
%37 = icmp slt i32 %35, %36
br i1 %37, label %38, label %61
38: ; preds = %34
%39 = load double*, double** %6
%40 = load i32, i32* %18
%41 = add nsw i32 %40, 1
store i32 %41, i32* %18
%42 = sext i32 %41 to i64
%43 = getelementptr inbounds double, double* %39, i64 %42
%44 = load double, double* %43
%45 = load double*, double** %7
%46 = load i32, i32* %11
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds double, double* %45, i64 %47
store double %44, double* %48
%49 = load double*, double** %7
%50 = load i32, i32* %11
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds double, double* %49, i64 %51
%53 = load double, double* %52
%54 = call i64 @fabs(double %53)
%55 = sitofp i64 %54 to double
%56 = load double, double* %12
%57 = fadd double %56, %55
store double %57, double* %12
br label %58
58: ; preds = %38
%59 = load i32, i32* %11
%60 = add nsw i32 %59, 1
store i32 %60, i32* %11
br label %34
61: ; preds = %34
%62 = load double, double* %12
%63 = fcmp oeq double %62, 0.000000e+00
br i1 %63, label %67, label %64
64: ; preds = %61
%65 = load i32, i32* %9
%66 = icmp ne i32 %65, 0
br i1 %66, label %86, label %67
67: ; preds = %64, %61
%68 = load double*, double** %8
%69 = load i32, i32* %9
%70 = sext i32 %69 to i64
%71 = getelementptr inbounds double, double* %68, i64 %70
store double 0.000000e+00, double* %71
%72 = load double*, double** %6
%73 = load i32, i32* %18
%74 = add nsw i32 %73, 1
store i32 %74, i32* %18
%75 = sext i32 %74 to i64
%76 = getelementptr inbounds double, double* %72, i64 %75
%77 = load double, double* %76
%78 = load double*, double** %7
%79 = load i32, i32* %9
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds double, double* %78, i64 %80
store double %77, double* %81
%82 = load double*, double** %6
%83 = load i32, i32* %18
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds double, double* %82, i64 %84
store double 0.000000e+00, double* %85
br label %21
86: ; preds = %64
%87 = load double, double* %12
%88 = fdiv double 1.000000e+00, %87
store double %88, double* %14
store i32 0, i32* %11
br label %89
89: ; preds = %113, %86
%90 = load i32, i32* %11
%91 = load i32, i32* %17
%92 = icmp sle i32 %90, %91
br i1 %92, label %93, label %116
93: ; preds = %89
%94 = load double, double* %14
%95 = load double*, double** %7
%96 = load i32, i32* %11
%97 = sext i32 %96 to i64
%98 = getelementptr inbounds double, double* %95, i64 %97
%99 = load double, double* %98
%100 = fmul double %99, %94
store double %100, double* %98
%101 = load double*, double** %7
%102 = load i32, i32* %11
%103 = sext i32 %102 to i64
%104 = getelementptr inbounds double, double* %101, i64 %103
%105 = load double, double* %104
%106 = load double*, double** %7
%107 = load i32, i32* %11
%108 = sext i32 %107 to i64
%109 = getelementptr inbounds double, double* %106, i64 %108
%110 = load double, double* %109
%111 = load double, double* %13
%112 = call double @llvm.fmuladd.f64(double %105, double %110, double %111)
store double %112, double* %13
br label %113
113: ; preds = %93
%114 = load i32, i32* %11
%115 = add nsw i32 %114, 1
store i32 %115, i32* %11
br label %89
116: ; preds = %89
%117 = load double*, double** %7
%118 = load i32, i32* %17
%119 = sext i32 %118 to i64
%120 = getelementptr inbounds double, double* %117, i64 %119
%121 = load double, double* %120
store double %121, double* %14
%122 = load double, double* %13
%123 = call double @sqrt(double %122)
%124 = fneg double %123
store double %124, double* %15
%125 = load double, double* %14
%126 = fcmp olt double %125, 0.000000e+00
br i1 %126, label %127, label %130
127: ; preds = %116
%128 = load double, double* %15
%129 = fneg double %128
store double %129, double* %15
br label %130
130: ; preds = %127, %116
%131 = load double, double* %12
%132 = load double, double* %15
%133 = fmul double %131, %132
%134 = load double*, double** %8
%135 = load i32, i32* %9
%136 = sext i32 %135 to i64
%137 = getelementptr inbounds double, double* %134, i64 %136
store double %133, double* %137
%138 = load double, double* %14
%139 = load double, double* %15
%140 = load double, double* %13
%141 = fneg double %138
%142 = call double @llvm.fmuladd.f64(double %141, double %139, double %140)
store double %142, double* %13
%143 = load double, double* %14
%144 = load double, double* %15
%145 = fsub double %143, %144
%146 = load double*, double** %7
%147 = load i32, i32* %17
%148 = sext i32 %147 to i64
%149 = getelementptr inbounds double, double* %146, i64 %148
store double %145, double* %149
%150 = load double, double* %12
%151 = load double*, double** %7
%152 = load i32, i32* %17
%153 = sext i32 %152 to i64
%154 = getelementptr inbounds double, double* %151, i64 %153
%155 = load double, double* %154
%156 = fmul double %150, %155
%157 = load double*, double** %6
%158 = load i32, i32* %18
%159 = sext i32 %158 to i64
%160 = getelementptr inbounds double, double* %157, i64 %159
store double %156, double* %160
%161 = load i32, i32* %9
%162 = icmp eq i32 %161, 1
br i1 %162, label %163, label %182
163: ; preds = %130
%164 = load double*, double** %6
%165 = load i32, i32* %18
%166 = add nsw i32 %165, 1
store i32 %166, i32* %18
%167 = sext i32 %166 to i64
%168 = getelementptr inbounds double, double* %164, i64 %167
%169 = load double, double* %168
%170 = load double*, double** %7
%171 = load i32, i32* %9
%172 = sext i32 %171 to i64
%173 = getelementptr inbounds double, double* %170, i64 %172
store double %169, double* %173
%174 = load double, double* %12
%175 = load double, double* %13
%176 = call double @sqrt(double %175)
%177 = fmul double %174, %176
%178 = load double*, double** %6
%179 = load i32, i32* %18
%180 = sext i32 %179 to i64
%181 = getelementptr inbounds double, double* %178, i64 %180
store double %177, double* %181
br label %21
182: ; preds = %130
store i32 0, i32* %19
store i32 0, i32* %10
br label %183
183: ; preds = %242, %182
%184 = load i32, i32* %10
%185 = load i32, i32* %17
%186 = icmp sle i32 %184, %185
br i1 %186, label %187, label %245
187: ; preds = %183
%188 = load double*, double** %7
%189 = load i32, i32* %10
%190 = sext i32 %189 to i64
%191 = getelementptr inbounds double, double* %188, i64 %190
%192 = load double, double* %191
store double %192, double* %14
store double 0.000000e+00, double* %15
store i32 0, i32* %11
br label %193
193: ; preds = %224, %187
%194 = load i32, i32* %11
%195 = load i32, i32* %10
%196 = icmp slt i32 %194, %195
br i1 %196, label %197, label %227
197: ; preds = %193
%198 = load double*, double** %6
%199 = load i32, i32* %19
%200 = sext i32 %199 to i64
%201 = getelementptr inbounds double, double* %198, i64 %200
%202 = load double, double* %201
%203 = load double*, double** %7
%204 = load i32, i32* %11
%205 = sext i32 %204 to i64
%206 = getelementptr inbounds double, double* %203, i64 %205
%207 = load double, double* %206
%208 = load double, double* %15
%209 = call double @llvm.fmuladd.f64(double %202, double %207, double %208)
store double %209, double* %15
%210 = load double*, double** %6
%211 = load i32, i32* %19
%212 = sext i32 %211 to i64
%213 = getelementptr inbounds double, double* %210, i64 %212
%214 = load double, double* %213
%215 = load double, double* %14
%216 = load double*, double** %8
%217 = load i32, i32* %11
%218 = sext i32 %217 to i64
%219 = getelementptr inbounds double, double* %216, i64 %218
%220 = load double, double* %219
%221 = call double @llvm.fmuladd.f64(double %214, double %215, double %220)
store double %221, double* %219
%222 = load i32, i32* %19
%223 = add nsw i32 %222, 1
store i32 %223, i32* %19
br label %224
224: ; preds = %197
%225 = load i32, i32* %11
%226 = add nsw i32 %225, 1
store i32 %226, i32* %11
br label %193
227: ; preds = %193
%228 = load double, double* %15
%229 = load double*, double** %6
%230 = load i32, i32* %19
%231 = sext i32 %230 to i64
%232 = getelementptr inbounds double, double* %229, i64 %231
%233 = load double, double* %232
%234 = load double, double* %14
%235 = call double @llvm.fmuladd.f64(double %233, double %234, double %228)
%236 = load double*, double** %8
%237 = load i32, i32* %10
%238 = sext i32 %237 to i64
%239 = getelementptr inbounds double, double* %236, i64 %238
store double %235, double* %239
%240 = load i32, i32* %19
%241 = add nsw i32 %240, 1
store i32 %241, i32* %19
br label %242
242: ; preds = %227
%243 = load i32, i32* %10
%244 = add nsw i32 %243, 1
store i32 %244, i32* %10
br label %183
245: ; preds = %183
store double 0.000000e+00, double* %14
store i32 0, i32* %10
br label %246
246: ; preds = %270, %245
%247 = load i32, i32* %10
%248 = load i32, i32* %9
%249 = icmp slt i32 %247, %248
br i1 %249, label %250, label %273
250: ; preds = %246
%251 = load double, double* %13
%252 = load double*, double** %8
%253 = load i32, i32* %10
%254 = sext i32 %253 to i64
%255 = getelementptr inbounds double, double* %252, i64 %254
%256 = load double, double* %255
%257 = fdiv double %256, %251
store double %257, double* %255
%258 = load double*, double** %8
%259 = load i32, i32* %10
%260 = sext i32 %259 to i64
%261 = getelementptr inbounds double, double* %258, i64 %260
%262 = load double, double* %261
%263 = load double*, double** %7
%264 = load i32, i32* %10
%265 = sext i32 %264 to i64
%266 = getelementptr inbounds double, double* %263, i64 %265
%267 = load double, double* %266
%268 = load double, double* %14
%269 = call double @llvm.fmuladd.f64(double %262, double %267, double %268)
store double %269, double* %14
br label %270
270: ; preds = %250
%271 = load i32, i32* %10
%272 = add nsw i32 %271, 1
store i32 %272, i32* %10
br label %246
273: ; preds = %246
%274 = load double, double* %14
%275 = fdiv double %274, 2.000000e+00
%276 = load double, double* %13
%277 = fdiv double %275, %276
store double %277, double* %16
store i32 0, i32* %10
br label %278
278: ; preds = %296, %273
%279 = load i32, i32* %10
%280 = load i32, i32* %9
%281 = icmp slt i32 %279, %280
br i1 %281, label %282, label %299
282: ; preds = %278
%283 = load double, double* %16
%284 = load double*, double** %7
%285 = load i32, i32* %10
%286 = sext i32 %285 to i64
%287 = getelementptr inbounds double, double* %284, i64 %286
%288 = load double, double* %287
%289 = load double*, double** %8
%290 = load i32, i32* %10
%291 = sext i32 %290 to i64
%292 = getelementptr inbounds double, double* %289, i64 %291
%293 = load double, double* %292
%294 = fneg double %283
%295 = call double @llvm.fmuladd.f64(double %294, double %288, double %293)
store double %295, double* %292
br label %296
296: ; preds = %282
%297 = load i32, i32* %10
%298 = add nsw i32 %297, 1
store i32 %298, i32* %10
br label %278
299: ; preds = %278
store i32 0, i32* %19
store i32 0, i32* %10
br label %300
300: ; preds = %346, %299
%301 = load i32, i32* %10
%302 = load i32, i32* %17
%303 = icmp sle i32 %301, %302
br i1 %303, label %304, label %349
304: ; preds = %300
%305 = load double*, double** %7
%306 = load i32, i32* %10
%307 = sext i32 %306 to i64
%308 = getelementptr inbounds double, double* %305, i64 %307
%309 = load double, double* %308
store double %309, double* %14
%310 = load double*, double** %8
%311 = load i32, i32* %10
%312 = sext i32 %311 to i64
%313 = getelementptr inbounds double, double* %310, i64 %312
%314 = load double, double* %313
store double %314, double* %15
store i32 0, i32* %11
br label %315
315: ; preds = %342, %304
%316 = load i32, i32* %11
%317 = load i32, i32* %10
%318 = icmp sle i32 %316, %317
br i1 %318, label %319, label %345
319: ; preds = %315
%320 = load double, double* %14
%321 = load double*, double** %8
%322 = load i32, i32* %11
%323 = sext i32 %322 to i64
%324 = getelementptr inbounds double, double* %321, i64 %323
%325 = load double, double* %324
%326 = load double, double* %15
%327 = load double*, double** %7
%328 = load i32, i32* %11
%329 = sext i32 %328 to i64
%330 = getelementptr inbounds double, double* %327, i64 %329
%331 = load double, double* %330
%332 = fmul double %326, %331
%333 = call double @llvm.fmuladd.f64(double %320, double %325, double %332)
%334 = load double*, double** %6
%335 = load i32, i32* %19
%336 = sext i32 %335 to i64
%337 = getelementptr inbounds double, double* %334, i64 %336
%338 = load double, double* %337
%339 = fsub double %338, %333
store double %339, double* %337
%340 = load i32, i32* %19
%341 = add nsw i32 %340, 1
store i32 %341, i32* %19
br label %342
342: ; preds = %319
%343 = load i32, i32* %11
%344 = add nsw i32 %343, 1
store i32 %344, i32* %11
br label %315
345: ; preds = %315
br label %346
346: ; preds = %345
%347 = load i32, i32* %10
%348 = add nsw i32 %347, 1
store i32 %348, i32* %10
br label %300
349: ; preds = %300
%350 = load double*, double** %6
%351 = load i32, i32* %18
%352 = add nsw i32 %351, 1
store i32 %352, i32* %18
%353 = sext i32 %352 to i64
%354 = getelementptr inbounds double, double* %350, i64 %353
%355 = load double, double* %354
%356 = load double*, double** %7
%357 = load i32, i32* %9
%358 = sext i32 %357 to i64
%359 = getelementptr inbounds double, double* %356, i64 %358
store double %355, double* %359
%360 = load double, double* %12
%361 = load double, double* %13
%362 = call double @sqrt(double %361)
%363 = fmul double %360, %362
%364 = load double*, double** %6
%365 = load i32, i32* %18
%366 = sext i32 %365 to i64
%367 = getelementptr inbounds double, double* %364, i64 %366
store double %363, double* %367
br label %21
368: ; preds = %21
ret void
}

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