#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 */
double fabs(double);
int fsquare(int);
int imax2(int, int);
int imin2(int, int);
int /*<<< orphan*/ lowest(double *, double *, int, double *, double *, int, int,
                          double *, int, double *, int *);
int /*<<< orphan*/ rPsort(double *, int, int);
void clowess(double *x, double *y, int n, double f, int nsteps, double delta,
             double *ys, double *rw, double *res) {
  int i, iter, j, last, m1, m2, nleft, nright, ns;
  int ok;
  double alpha, c1, c9, cmad, cut, d1, d2, denom, r, sc;
  if (n < 2) {
    ys[0] = y[0];
    return;
  }
  x--;
  y--;
  ys--;
  ns = imax2(2, imin2(n, (int)(f * n + 1e-7)));
  iter = 1;
  while (iter <= nsteps + 1) {
    nleft = 1;
    nright = ns;
    last = 0;
    i = 1;
    for (;;) {
      if (nright < n) {
        d1 = x[i] - x[nleft];
        d2 = x[nright + 1] - x[i];
        if (d1 > d2) {
          nleft++;
          nright++;
          continue;
        }
      }
      lowest(&x[1], &y[1], n, &x[i], &ys[i], nleft, nright, res, iter > 1, rw,
             &ok);
      if (!ok)
        ys[i] = y[i];
      if (last < i - 1) {
        denom = x[i] - x[last];
        for (j = last + 1; j < i; j++) {
          alpha = (x[j] - x[last]) / denom;
          ys[j] = alpha * ys[i] + (1. - alpha) * ys[last];
        }
      }
      last = i;
      cut = x[last] + delta;
      for (i = last + 1; i <= n; i++) {
        if (x[i] > cut)
          break;
        if (x[i] == x[last]) {
          ys[i] = ys[last];
          last = i;
        }
      }
      i = imax2(last + 1, i - 1);
      if (last >= n)
        break;
    }
    for (i = 0; i < n; i++)
      res[i] = y[i + 1] - ys[i + 1];
    sc = 0.;
    for (i = 0; i < n; i++)
      sc += fabs(res[i]);
    sc /= n;
    if (iter > nsteps)
      break;
    for (i = 0; i < n; i++)
      rw[i] = fabs(res[i]);
    m1 = n / 2;
    rPsort((double *)rw, (int)n, (int)m1);
    if (n % 2 == 0) {
      m2 = n - m1 - 1;
      rPsort((double *)rw, (int)n, (int)m2);
      cmad = 3. * (rw[m1] + rw[m2]);
    } else {
      cmad = 6. * rw[m1];
    }
    if (cmad < 1e-7 * sc)
      break;
    c9 = 0.999 * cmad;
    c1 = 0.001 * cmad;
    for (i = 0; i < n; i++) {
      r = fabs(res[i]);
      if (r <= c1)
        rw[i] = 1.;
      else if (r <= c9)
        rw[i] = fsquare(1. - fsquare(r / cmad));
      else
        rw[i] = 0.;
    }
    iter++;
  }
}


x86 assembly (clang, -O0):
<clowess>:
push   %rbp
mov    %rsp,%rbp
push   %r14
push   %rbx
sub    $0xe0,%rsp
mov    0x10(%rbp),%rax
mov    %rdi,-0x18(%rbp)
mov    %rsi,-0x20(%rbp)
mov    %edx,-0x24(%rbp)
movsd  %xmm0,-0x30(%rbp)
mov    %ecx,-0x34(%rbp)
movsd  %xmm1,-0x40(%rbp)
mov    %r8,-0x48(%rbp)
mov    %r9,-0x50(%rbp)
cmpl   $0x2,-0x24(%rbp)
jge    11a1 <clowess+0x51>
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x48(%rbp),%rax
movsd  %xmm0,(%rax)
jmp    17ea <clowess+0x69a>
mov    -0x18(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x18(%rbp)
mov    -0x20(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x20(%rbp)
mov    -0x48(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x48(%rbp)
mov    -0x24(%rbp),%edi
movsd  -0x30(%rbp),%xmm0
cvtsi2sdl -0x24(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xe22(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%esi
call   1050 <imin2@plt>
mov    %eax,%esi
mov    $0x2,%edi
call   1070 <imax2@plt>
mov    %eax,-0x74(%rbp)
movl   $0x1,-0x58(%rbp)
mov    -0x58(%rbp),%eax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jg     17ea <clowess+0x69a>
movl   $0x1,-0x6c(%rbp)
mov    -0x74(%rbp),%eax
mov    %eax,-0x70(%rbp)
movl   $0x0,-0x60(%rbp)
movl   $0x1,-0x54(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    12b4 <clowess+0x164>
mov    -0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x6c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x70(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
ucomisd -0xb0(%rbp),%xmm0
ff
jbe    12af <clowess+0x15f>
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    122d <clowess+0xdd>
jmp    12b4 <clowess+0x164>
mov    -0x18(%rbp),%rdi
add    $0x8,%rdi
mov    -0x20(%rbp),%rsi
add    $0x8,%rsi
mov    -0x24(%rbp),%edx
mov    -0x18(%rbp),%rcx
movslq -0x54(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rcx
mov    -0x48(%rbp),%r8
movslq -0x54(%rbp),%rax
shl    $0x3,%rax
add    %rax,%r8
mov    -0x6c(%rbp),%r9d
mov    -0x70(%rbp),%r14d
mov    0x10(%rbp),%rbx
cmpl   $0x1,-0x58(%rbp)
setg   %al
and    $0x1,%al
movzbl %al,%r11d
mov    -0x50(%rbp),%r10
lea    -0x78(%rbp),%rax
mov    %r14d,(%rsp)
mov    %rbx,0x8(%rsp)
mov    %r11d,0x10(%rsp)
mov    %r10,0x18(%rsp)
mov    %rax,0x20(%rsp)
call   1030 <lowest@plt>
cmpl   $0x0,-0x78(%rbp)
jne    1347 <clowess+0x1f7>
mov    -0x20(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x60(%rbp),%eax
mov    -0x54(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    140a <clowess+0x2ba>
mov    -0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x60(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    1405 <clowess+0x2b5>
mov    -0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x60(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
divsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0xc58(%rip),%xmm1
subsd  -0x80(%rbp),%xmm1
mov    -0x48(%rbp),%rax
movslq -0x60(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1383 <clowess+0x233>
jmp    140a <clowess+0x2ba>
mov    -0x54(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     14b8 <clowess+0x368>
mov    -0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0xa0(%rbp),%xmm0
ff
jbe    145f <clowess+0x30f>
jmp    14b8 <clowess+0x368>
mov    -0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x60(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jne    14a5 <clowess+0x355>
jp     14a5 <clowess+0x355>
mov    -0x48(%rbp),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
mov    %eax,-0x60(%rbp)
jmp    14aa <clowess+0x35a>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1433 <clowess+0x2e3>
mov    -0x60(%rbp),%edi
add    $0x1,%edi
mov    -0x54(%rbp),%esi
sub    $0x1,%esi
call   1070 <imax2@plt>
mov    %eax,-0x54(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x24(%rbp),%eax
jl     14dd <clowess+0x38d>
jmp    14e2 <clowess+0x392>
jmp    122d <clowess+0xdd>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1534 <clowess+0x3e4>
mov    -0x20(%rbp),%rax
mov    -0x54(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x54(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    14e9 <clowess+0x399>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1588 <clowess+0x438>
mov    0x10(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xaca(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1546 <clowess+0x3f6>
cvtsi2sdl -0x24(%rbp),%xmm1
movsd  -0xc8(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x58(%rbp),%eax
cmp    -0x34(%rbp),%eax
jle    15b2 <clowess+0x462>
jmp    17ea <clowess+0x69a>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    15f8 <clowess+0x4a8>
mov    0x10(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xa57(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x50(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    15b9 <clowess+0x469>
mov    -0x24(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x64(%rbp)
mov    -0x50(%rbp),%rdi
mov    -0x24(%rbp),%esi
mov    -0x64(%rbp),%edx
call   1060 <rPsort@plt>
mov    -0x24(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    1677 <clowess+0x527>
mov    -0x24(%rbp),%eax
sub    -0x64(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x68(%rbp)
mov    -0x50(%rbp),%rdi
mov    -0x24(%rbp),%esi
mov    -0x68(%rbp),%edx
call   1060 <rPsort@plt>
mov    -0x50(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x50(%rbp),%rax
movslq -0x68(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm1
movsd  0x9aa(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
jmp    1694 <clowess+0x544>
mov    -0x50(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  0x981(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x98(%rbp),%xmm1
ff
movsd  0x95c(%rip),%xmm0
mulsd  -0xc8(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    16bb <clowess+0x56b>
jmp    17ea <clowess+0x69a>
movsd  0x95d(%rip),%xmm0
mulsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
movsd  0x93d(%rip),%xmm0
mulsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    17dc <clowess+0x68c>
mov    0x10(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x91e(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xc0(%rbp),%xmm1
ff
movsd  -0x88(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jb     1752 <clowess+0x602>
mov    -0x50(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  0x8e0(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    17c9 <clowess+0x679>
movsd  -0xc0(%rbp),%xmm1
ff
movsd  -0x90(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jb     17b4 <clowess+0x664>
movsd  -0xc0(%rbp),%xmm0
ff
divsd  -0x98(%rbp),%xmm0
ff
cvttsd2si %xmm0,%edi
call   1040 <fsquare@plt>
cvtsi2sd %eax,%xmm1
movsd  0x897(%rip),%xmm0
subsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   1040 <fsquare@plt>
cvtsi2sd %eax,%xmm0
mov    -0x50(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    17c4 <clowess+0x674>
mov    -0x50(%rbp),%rax
movslq -0x54(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    17c9 <clowess+0x679>
jmp    17ce <clowess+0x67e>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    16f2 <clowess+0x5a2>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1201 <clowess+0xb1>
add    $0xe0,%rsp
pop    %rbx
pop    %r14
pop    %rbp
ret

x86 assembly (clang, -O2):
<clowess>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xe8,%rsp
mov    %r8,%r15
mov    %rsi,%r12
cmp    $0x1,%edx
jg     117c <clowess+0x2c>
movsd  (%r12),%xmm0
movsd  %xmm0,(%r15)
jmp    1b2b <clowess+0x9db>
mov    %r9,%r14
mov    %ecx,%ebx
movsd  %xmm1,0xd8(%rsp)
xorps  %xmm1,%xmm1
cvtsi2sd %edx,%xmm1
movsd  %xmm1,0xc0(%rsp)
mulsd  %xmm1,%xmm0
addsd  0xe5a(%rip),%xmm0
mov    %rdi,0x8(%rsp)
cvttsd2si %xmm0,%esi
mov    %edx,0x4(%rsp)
mov    %edx,%edi
call   1050 <imin2@plt>
mov    $0x2,%edi
mov    %eax,%esi
call   1070 <imax2@plt>
mov    0x8(%rsp),%rdx
test   %ebx,%ebx
js     1b2b <clowess+0x9db>
mov    0x120(%rsp),%r9
mov    0x4(%rsp),%ecx
mov    %ecx,%r13d
lea    -0x8(%rdx),%rsi
lea    -0x8(%r15),%rbp
mov    %ecx,%edx
shr    %edx
mov    %rdx,0x78(%rsp)
mov    %edx,%r11d
not    %r11d
add    %ecx,%r11d
add    $0x1,%ebx
mov    %ebx,0x14(%rsp)
lea    (%r9,%r13,8),%r10
lea    (%r12,%r13,8),%rcx
mov    %r13d,%edi
and    $0xfffffffc,%edi
mov    %rdi,0xa8(%rsp)
add    $0xfffffffffffffffc,%rdi
mov    %rdi,0x98(%rsp)
mov    %rdi,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
cmp    %r9,%rcx
seta   %r8b
lea    (%r15,%r13,8),%rdi
mov    %r12,0x58(%rsp)
cmp    %r12,%r10
seta   %cl
and    %r8b,%cl
cmp    %r9,%rdi
seta   %r8b
movslq %r11d,%rdi
mov    %rdi,0xb8(%rsp)
mov    %r15,0x40(%rsp)
cmp    %r15,%r10
seta   %bl
cltq
mov    %rax,0xc8(%rsp)
and    %r8b,%bl
mov    0x8(%rsp),%rdi
or     %cl,%bl
mov    %bl,0x3(%rsp)
mov    %rdx,%rax
mov    %rdx,0x90(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,0x88(%rsp)
mov    %r13d,%eax
and    $0x3,%eax
mov    %rax,0xa0(%rsp)
cmp    %r14,%r10
mov    %r13,%r10
seta   %al
mov    %r14,0x48(%rsp)
lea    (%r14,%r13,8),%rcx
cmp    %r9,%rcx
seta   %cl
lea    -0x1(%r13),%rdx
mov    %rdx,0xb0(%rsp)
and    %al,%cl
mov    %cl,0x2(%rsp)
mov    $0x1,%r13d
mov    %r10,0x20(%rsp)
mov    %rsi,0x30(%rsp)
mov    %rbp,0x28(%rsp)
jmp    12f4 <clowess+0x1a4>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r13d
xor    %eax,%eax
mov    %r13d,0x3c(%rsp)
cmp    $0x2,%r13d
setae  %al
mov    %rax,0xe0(%rsp)
mov    $0x1,%eax
mov    %rax,0x18(%rsp)
mov    0xc8(%rsp),%rbx
xor    %r13d,%r13d
mov    $0x1,%r15d
mov    0x4(%rsp),%r14d
lea    0x1(%rbx),%rax
mov    %rax,0xd0(%rsp)
mov    %rbx,0x50(%rsp)
jmp    137f <clowess+0x22f>
nopl   (%rax)
mov    %r15d,%r12d
mov    0x50(%rsp),%rbx
lea    0x1(%r15),%edi
mov    %r12d,%esi
call   1070 <imax2@plt>
mov    %r15d,%r13d
cmp    %r14d,%r15d
mov    %eax,%r15d
mov    0x8(%rsp),%rdi
mov    0x30(%rsp),%rsi
mov    0x28(%rsp),%rbp
movapd 0xcbc(%rip),%xmm4
mov    0x20(%rsp),%r10
jge    1570 <clowess+0x420>
movslq %r15d,%r12
cmp    %r10,%rbx
jge    13ac <clowess+0x25c>
movsd  -0x8(%rdi,%r12,8),%xmm0
movsd  (%rdi,%rbx,8),%xmm1
subsd  %xmm0,%xmm1
mov    0x18(%rsp),%rax
subsd  -0x8(%rdi,%rax,8),%xmm0
ucomisd %xmm1,%xmm0
ja     1550 <clowess+0x400>
lea    (%rsi,%r12,8),%rcx
mov    %r14d,%edx
lea    0x0(,%r12,8),%r14
add    %rbp,%r14
sub    $0x8,%rsp
mov    0x60(%rsp),%rsi
mov    %rcx,0x68(%rsp)
mov    %r14,%r8
mov    0x20(%rsp),%r9
lea    0x8c(%rsp),%rax
push   %rax
push   0x58(%rsp)
push   0xf8(%rsp)
push   0x140(%rsp)
push   %rbx
call   1030 <lowest@plt>
add    $0x30,%rsp
cmpl   $0x0,0x84(%rsp)
jne    1414 <clowess+0x2c4>
mov    0x58(%rsp),%rax
movsd  -0x8(%rax,%r12,8),%xmm0
movsd  %xmm0,(%r14)
lea    -0x1(%r15),%eax
cmp    %eax,%r13d
mov    0x30(%rsp),%rbp
mov    0x28(%rsp),%rbx
movsd  0xbdb(%rip),%xmm3
jge    14c0 <clowess+0x370>
lea    0x1(%r13),%eax
cmp    %r15d,%eax
jge    14c0 <clowess+0x370>
mov    0x60(%rsp),%rax
movsd  (%rax),%xmm0
movslq %r13d,%rax
movsd  0x0(%rbp,%rax,8),%xmm1
subsd  %xmm1,%xmm0
mov    0x8(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    0x40(%rsp),%rdx
lea    (%rdx,%rax,8),%rdx
mov    %r15d,%esi
sub    %r13d,%esi
add    $0xfffffffe,%esi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rcx,%rdi,8),%xmm2
subsd  %xmm1,%xmm2
divsd  %xmm0,%xmm2
movapd %xmm3,%xmm1
subsd  %xmm2,%xmm1
mulsd  (%rbx,%rax,8),%xmm1
mulsd  (%r14),%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,(%rdx,%rdi,8)
cmp    %edi,%esi
je     14c0 <clowess+0x370>
movsd  0x0(%rbp,%rax,8),%xmm1
add    $0x1,%rdi
jmp    1480 <clowess+0x330>
nopl   0x0(%rax,%rax,1)
mov    0x4(%rsp),%r14d
cmp    %r14d,%r15d
jge    1340 <clowess+0x1f0>
mov    0x60(%rsp),%rax
movsd  (%rax),%xmm0
addsd  0xd8(%rsp),%xmm0
mov    0x40(%rsp),%rdx
mov    0x8(%rsp),%rsi
mov    0x20(%rsp),%rdi
mov    0x50(%rsp),%rbx
jmp    1508 <clowess+0x3b8>
cs nopw 0x0(%rax,%rax,1)
mov    %rax,%r12
cmp    %rax,%rdi
je     1540 <clowess+0x3f0>
movsd  (%rsi,%r12,8),%xmm1
ucomisd %xmm0,%xmm1
ja     1348 <clowess+0x1f8>
lea    0x1(%r12),%rax
movslq %r15d,%rcx
ucomisd 0x0(%rbp,%rcx,8),%xmm1
jne    1500 <clowess+0x3b0>
jp     1500 <clowess+0x3b0>
movsd  -0x8(%rdx,%rcx,8),%xmm1
movsd  %xmm1,(%rdx,%r12,8)
lea    0x1(%r12),%r15d
jmp    1500 <clowess+0x3b0>
nopl   (%rax)
mov    %edi,%r12d
jmp    1348 <clowess+0x1f8>
nopl   0x0(%rax,%rax,1)
addq   $0x1,0x18(%rsp)
mov    0xd0(%rsp),%rbx
jmp    132a <clowess+0x1da>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cmp    $0x4,%r14d
setb   %al
or     0x3(%rsp),%al
je     15c0 <clowess+0x470>
xor    %edx,%edx
mov    0x40(%rsp),%rdi
mov    0x48(%rsp),%r14
mov    0x14(%rsp),%r8d
mov    0x58(%rsp),%rbx
mov    0x120(%rsp),%r15
mov    0xa8(%rsp),%r9
mov    0xa0(%rsp),%rbp
mov    0x3c(%rsp),%r13d
jmp    16b4 <clowess+0x564>
cs nopw 0x0(%rax,%rax,1)
nop
cmpq   $0x0,0x98(%rsp)
mov    0x40(%rsp),%rdi
mov    0x58(%rsp),%rbx
mov    0x120(%rsp),%r15
mov    0xa8(%rsp),%r9
mov    0xa0(%rsp),%rbp
mov    0x3c(%rsp),%r13d
je     1af2 <clowess+0x9a2>
mov    0x88(%rsp),%rcx
xor    %eax,%eax
mov    0x48(%rsp),%r14
mov    0x14(%rsp),%r8d
nopw   0x0(%rax,%rax,1)
movupd (%rbx,%rax,8),%xmm0
movupd 0x10(%rbx,%rax,8),%xmm1
movupd (%rdi,%rax,8),%xmm2
subpd  %xmm2,%xmm0
movupd 0x10(%rdi,%rax,8),%xmm2
subpd  %xmm2,%xmm1
movupd %xmm0,(%r15,%rax,8)
movupd %xmm1,0x10(%r15,%rax,8)
movupd 0x20(%rbx,%rax,8),%xmm0
movupd 0x30(%rbx,%rax,8),%xmm1
movupd 0x20(%rdi,%rax,8),%xmm2
subpd  %xmm2,%xmm0
movupd 0x30(%rdi,%rax,8),%xmm2
subpd  %xmm2,%xmm1
movupd %xmm0,0x20(%r15,%rax,8)
movupd %xmm1,0x30(%r15,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    1610 <clowess+0x4c0>
testb  $0x1,0x90(%rsp)
01
je     16a8 <clowess+0x558>
movupd (%rbx,%rax,8),%xmm0
movupd 0x10(%rbx,%rax,8),%xmm1
movupd (%rdi,%rax,8),%xmm2
subpd  %xmm2,%xmm0
movupd 0x10(%rdi,%rax,8),%xmm2
subpd  %xmm2,%xmm1
movupd %xmm0,(%r15,%rax,8)
movupd %xmm1,0x10(%r15,%rax,8)
mov    %r9,%rdx
cmp    %r10,%r9
je     1755 <clowess+0x605>
mov    0xb0(%rsp),%rcx
sub    %rdx,%rcx
test   %rbp,%rbp
je     1ae0 <clowess+0x990>
mov    %rbp,%rsi
nopl   0x0(%rax,%rax,1)
lea    0x1(%rdx),%rax
movsd  (%rbx,%rdx,8),%xmm0
subsd  (%rdi,%rdx,8),%xmm0
movsd  %xmm0,(%r15,%rdx,8)
mov    %rax,%rdx
add    $0xffffffffffffffff,%rsi
jne    16d0 <clowess+0x580>
cmp    $0x3,%rcx
jb     1755 <clowess+0x605>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rbx,%rax,8),%xmm0
subsd  (%rdi,%rax,8),%xmm0
movsd  %xmm0,(%r15,%rax,8)
movsd  0x8(%rbx,%rax,8),%xmm0
subsd  0x8(%rdi,%rax,8),%xmm0
movsd  %xmm0,0x8(%r15,%rax,8)
movsd  0x10(%rbx,%rax,8),%xmm0
subsd  0x10(%rdi,%rax,8),%xmm0
movsd  %xmm0,0x10(%r15,%rax,8)
movsd  0x18(%rbx,%rax,8),%xmm0
subsd  0x18(%rdi,%rax,8),%xmm0
movsd  %xmm0,0x18(%r15,%rax,8)
lea    0x4(%rax),%rcx
mov    %rcx,%rax
cmp    %rcx,%r10
jne    1700 <clowess+0x5b0>
cmpq   $0x3,0xb0(%rsp)
jae    1770 <clowess+0x620>
xorpd  %xmm5,%xmm5
xor    %eax,%eax
movapd 0x8c2(%rip),%xmm1
jmp    17d8 <clowess+0x688>
xorpd  %xmm0,%xmm0
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
movsd  (%r15,%rax,8),%xmm1
movsd  0x8(%r15,%rax,8),%xmm2
movsd  0x10(%r15,%rax,8),%xmm3
movsd  0x18(%r15,%rax,8),%xmm5
andpd  0x88d(%rip),%xmm1
addsd  %xmm0,%xmm1
andpd  0x881(%rip),%xmm2
addsd  %xmm1,%xmm2
movapd 0x875(%rip),%xmm1
andpd  %xmm1,%xmm3
addsd  %xmm2,%xmm3
andpd  %xmm1,%xmm5
addsd  %xmm3,%xmm5
add    $0x4,%rax
movapd %xmm5,%xmm0
cmp    %rax,%r9
jne    1780 <clowess+0x630>
test   $0x3,%r10b
je     1806 <clowess+0x6b6>
lea    (%r15,%rax,8),%rax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rax,%rcx,8),%xmm0
andpd  %xmm4,%xmm0
addsd  %xmm0,%xmm5
add    $0x1,%rcx
cmp    %rcx,%rbp
jne    17f0 <clowess+0x6a0>
cmp    %r8d,%r13d
je     1b2b <clowess+0x9db>
cmpl   $0x4,0x4(%rsp)
setb   %al
or     0x2(%rsp),%al
je     1830 <clowess+0x6e0>
xor    %eax,%eax
mov    0x78(%rsp),%r12
jmp    18e0 <clowess+0x790>
nopl   0x0(%rax)
cmpq   $0x0,0x98(%rsp)
je     1b11 <clowess+0x9c1>
mov    0x88(%rsp),%rcx
xor    %eax,%eax
mov    0x78(%rsp),%r12
xchg   %ax,%ax
movupd (%r15,%rax,8),%xmm0
movupd 0x10(%r15,%rax,8),%xmm1
andpd  %xmm4,%xmm0
andpd  %xmm4,%xmm1
movupd %xmm0,(%r14,%rax,8)
movupd %xmm1,0x10(%r14,%rax,8)
movupd 0x20(%r15,%rax,8),%xmm0
movupd 0x30(%r15,%rax,8),%xmm1
andpd  %xmm4,%xmm0
andpd  %xmm4,%xmm1
movupd %xmm0,0x20(%r14,%rax,8)
movupd %xmm1,0x30(%r14,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    1850 <clowess+0x700>
testb  $0x1,0x90(%rsp)
01
je     18cc <clowess+0x77c>
movupd (%r15,%rax,8),%xmm0
movupd 0x10(%r15,%rax,8),%xmm1
andpd  %xmm4,%xmm0
andpd  %xmm4,%xmm1
movupd %xmm0,(%r14,%rax,8)
movupd %xmm1,0x10(%r14,%rax,8)
mov    %r9,%rax
cmp    %r10,%r9
movapd 0x756(%rip),%xmm1
je     196f <clowess+0x81f>
mov    %rax,%rcx
not    %rcx
add    %r10,%rcx
test   $0x3,%r10b
je     191a <clowess+0x7ca>
mov    %rbp,%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%r15,%rax,8),%xmm0
andpd  %xmm4,%xmm0
movlpd %xmm0,(%r14,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1900 <clowess+0x7b0>
cmp    $0x3,%rcx
jb     196f <clowess+0x81f>
movsd  (%r15,%rax,8),%xmm0
andpd  %xmm1,%xmm0
movlpd %xmm0,(%r14,%rax,8)
movsd  0x8(%r15,%rax,8),%xmm0
andpd  %xmm1,%xmm0
movlpd %xmm0,0x8(%r14,%rax,8)
movsd  0x10(%r15,%rax,8),%xmm0
andpd  %xmm1,%xmm0
movlpd %xmm0,0x10(%r14,%rax,8)
movsd  0x18(%r15,%rax,8),%xmm0
andpd  %xmm1,%xmm0
movlpd %xmm0,0x18(%r14,%rax,8)
add    $0x4,%rax
cmp    %rax,%r10
jne    1920 <clowess+0x7d0>
movapd %xmm5,0x60(%rsp)
mov    %r14,%rdi
mov    0x4(%rsp),%ebx
mov    %ebx,%esi
mov    %r12d,%edx
call   1060 <rPsort@plt>
test   $0x1,%bl
jne    19c0 <clowess+0x870>
mov    %r14,%rdi
mov    %ebx,%esi
mov    0xb8(%rsp),%rbx
mov    %ebx,%edx
call   1060 <rPsort@plt>
movsd  (%r14,%r12,8),%xmm4
addsd  (%r14,%rbx,8),%xmm4
mulsd  0x665(%rip),%xmm4
jmp    19ce <clowess+0x87e>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%r14,%r12,8),%xmm4
mulsd  0x642(%rip),%xmm4
mov    0x8(%rsp),%rdi
mov    0x30(%rsp),%rsi
mov    0x28(%rsp),%rbp
movsd  0x623(%rip),%xmm2
movapd 0x643(%rip),%xmm3
mov    0x20(%rsp),%r10
movapd 0x60(%rsp),%xmm0
divsd  0xc0(%rsp),%xmm0
mulsd  0x5f7(%rip),%xmm0
ucomisd %xmm4,%xmm0
ja     1b2b <clowess+0x9db>
movapd %xmm4,%xmm5
mulsd  0x601(%rip),%xmm5
movapd %xmm4,%xmm6
mulsd  0x5fd(%rip),%xmm6
xor    %ebx,%ebx
movsd  %xmm4,0x60(%rsp)
movsd  %xmm5,0x18(%rsp)
movsd  %xmm6,0x50(%rsp)
jmp    1a63 <clowess+0x913>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  %xmm1,(%r14,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%r10
je     12f0 <clowess+0x1a0>
movsd  (%r15,%rbx,8),%xmm0
andpd  %xmm3,%xmm0
ucomisd %xmm0,%xmm6
movapd %xmm2,%xmm1
jae    1a50 <clowess+0x900>
xorpd  %xmm1,%xmm1
ucomisd %xmm0,%xmm5
jb     1a50 <clowess+0x900>
divsd  %xmm4,%xmm0
cvttsd2si %xmm0,%edi
call   1040 <fsquare@plt>
mov    $0x1,%edi
sub    %eax,%edi
call   1040 <fsquare@plt>
movsd  0x50(%rsp),%xmm6
movsd  0x18(%rsp),%xmm5
movsd  0x60(%rsp),%xmm4
mov    0x20(%rsp),%r10
movapd 0x577(%rip),%xmm3
movsd  0x547(%rip),%xmm2
mov    0x28(%rsp),%rbp
mov    0x30(%rsp),%rsi
mov    0x8(%rsp),%rdi
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
jmp    1a50 <clowess+0x900>
nopl   0x0(%rax)
mov    %rdx,%rax
cmp    $0x3,%rcx
jae    1700 <clowess+0x5b0>
jmp    1755 <clowess+0x605>
xor    %eax,%eax
mov    0x48(%rsp),%r14
mov    0x14(%rsp),%r8d
testb  $0x1,0x90(%rsp)
01
jne    167d <clowess+0x52d>
jmp    16a8 <clowess+0x558>
xor    %eax,%eax
mov    0x78(%rsp),%r12
testb  $0x1,0x90(%rsp)
01
jne    18aa <clowess+0x75a>
jmp    18cc <clowess+0x77c>
add    $0xe8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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