#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 fcube(int);
double fmax2(double, double);
double fsquare(double);
double sqrt(double);
void lowest(double *x, double *y, int n, double *xs, double *ys, int nleft,
            int nright, double *w, int userw, double *rw, int *ok) {
  int nrt, j;
  double a, b, c, h, h1, h9, r, range;
  x--;
  y--;
  w--;
  rw--;
  range = x[n] - x[1];
  h = fmax2(*xs - x[nleft], x[nright] - *xs);
  h9 = 0.999 * h;
  h1 = 0.001 * h;
  a = 0.;
  j = nleft;
  while (j <= n) {
    w[j] = 0.;
    r = fabs(x[j] - *xs);
    if (r <= h9) {
      if (r <= h1)
        w[j] = 1.;
      else
        w[j] = fcube(1. - fcube(r / h));
      if (userw)
        w[j] *= rw[j];
      a += w[j];
    } else if (x[j] > *xs)
      break;
    j = j + 1;
  }
  nrt = j - 1;
  if (a <= 0.)
    *ok = 0;
  else {
    *ok = 1;
    for (j = nleft; j <= nrt; j++)
      w[j] /= a;
    if (h > 0.) {
      a = 0.;
      for (j = nleft; j <= nrt; j++)
        a += w[j] * x[j];
      b = *xs - a;
      c = 0.;
      for (j = nleft; j <= nrt; j++)
        c += w[j] * fsquare(x[j] - a);
      if (sqrt(c) > 0.001 * range) {
        b /= c;
        for (j = nleft; j <= nrt; j++)
          w[j] *= (b * (x[j] - a) + 1.);
      }
    }
    *ys = 0.;
    for (j = nleft; j <= nrt; j++)
      *ys += w[j] * y[j];
  }
}


x86 assembly (clang, -O0):
<lowest>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x8(%rbp)
mov    -0x10(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x10(%rbp)
mov    0x18(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x18(%rbp)
mov    0x28(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x28(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
subsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq 0x10(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
subsd  (%rax),%xmm1
call   1040 <fmax2@plt>
movsd  %xmm0,-0x58(%rbp)
movsd  0xe0d(%rip),%xmm0
mulsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  0xdf3(%rip),%xmm0
mulsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     135d <lowest+0x21d>
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
subsd  (%rax),%xmm0
movaps 0xdc3(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm1
movsd  -0x68(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     132a <lowest+0x1ea>
movsd  -0x70(%rbp),%xmm1
movsd  -0x60(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     12a8 <lowest+0x168>
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  0xd72(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    12e5 <lowest+0x1a5>
movsd  -0x70(%rbp),%xmm0
divsd  -0x58(%rbp),%xmm0
cvttsd2si %xmm0,%edi
call   1030 <fcube@plt>
cvtsi2sd %eax,%xmm1
movsd  0xd49(%rip),%xmm0
subsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   1030 <fcube@plt>
cvtsi2sd %eax,%xmm0
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x0,0x20(%rbp)
je     130e <lowest+0x1ce>
mov    0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
jmp    134f <lowest+0x20f>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
ucomisd (%rax),%xmm0
jbe    134a <lowest+0x20a>
jmp    135d <lowest+0x21d>
jmp    134f <lowest+0x20f>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1225 <lowest+0xe5>
mov    -0x34(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x30(%rbp)
xorps  %xmm0,%xmm0
ucomisd -0x40(%rbp),%xmm0
jb     1383 <lowest+0x243>
mov    0x30(%rbp),%rax
movl   $0x0,(%rax)
jmp    15a0 <lowest+0x460>
mov    0x30(%rbp),%rax
movl   $0x1,(%rax)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x30(%rbp),%eax
jg     13c8 <lowest+0x288>
movsd  -0x40(%rbp),%xmm1
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1393 <lowest+0x253>
movsd  -0x58(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1542 <lowest+0x402>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x30(%rbp),%eax
jg     142e <lowest+0x2ee>
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x40(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    13e8 <lowest+0x2a8>
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm0
subsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x30(%rbp),%eax
jg     14ab <lowest+0x36b>
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x40(%rbp),%xmm0
call   1050 <fsquare@plt>
movaps %xmm0,%xmm2
movsd  -0x80(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    144e <lowest+0x30e>
movsd  -0x50(%rbp),%xmm0
call   1060 <sqrt@plt>
movsd  0xb43(%rip),%xmm1
mulsd  -0x78(%rbp),%xmm1
ucomisd %xmm1,%xmm0
jbe    153d <lowest+0x3fd>
movsd  -0x50(%rbp),%xmm1
movsd  -0x48(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x30(%rbp),%eax
jg     1538 <lowest+0x3f8>
movsd  -0x48(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
subsd  -0x40(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xafc(%rip),%xmm1
addsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    14e5 <lowest+0x3a5>
jmp    153d <lowest+0x3fd>
jmp    1542 <lowest+0x402>
mov    -0x28(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x30(%rbp),%eax
jg     159b <lowest+0x45b>
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1553 <lowest+0x413>
jmp    15a0 <lowest+0x460>
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<lowest>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x98,%rsp
mov    %r8,%r13
mov    %edx,%ebp
mov    %rsi,0x88(%rsp)
mov    %rdi,%r14
mov    0xf0(%rsp),%r12
movslq 0xd0(%rsp),%rax
movslq %edx,%rbx
movsd  -0x8(%rdi,%rbx,8),%xmm0
subsd  (%rdi),%xmm0
movsd  %xmm0,0x78(%rsp)
mov    %rcx,0x28(%rsp)
movsd  (%rcx),%xmm0
mov    %r9d,0x14(%rsp)
movslq %r9d,%r15
movsd  -0x8(%rdi,%rax,8),%xmm1
subsd  %xmm0,%xmm1
subsd  -0x8(%rdi,%r15,8),%xmm0
call   1040 <fmax2@plt>
cmp    %ebx,%r15d
jg     157a <lowest+0x43a>
mov    %r13,0x80(%rsp)
mov    0xe8(%rsp),%rax
mov    0xe0(%rsp),%r12d
mov    0xd8(%rsp),%rcx
movsd  0xe24(%rip),%xmm5
mulsd  %xmm0,%xmm5
movsd  0xe20(%rip),%xmm6
mulsd  %xmm0,%xmm6
mov    %r15d,%esi
lea    0x1(%rbp),%edx
mov    %rdx,0x8(%rsp)
lea    -0x8(%rcx,%r15,8),%r13
mov    %r14,0x18(%rsp)
lea    -0x8(%r14,%r15,8),%r9
lea    -0x8(%rax,%r15,8),%rax
mov    %rax,0x38(%rsp)
not    %ebp
mov    %rsi,0x20(%rsp)
add    %rsi,%rbp
xorpd  %xmm8,%xmm8
xor    %r14d,%r14d
movapd 0xdf6(%rip),%xmm7
movsd  0xdde(%rip),%xmm4
mov    %r9,0x30(%rsp)
mov    0x28(%rsp),%rbx
movsd  %xmm0,0x50(%rsp)
movsd  %xmm5,0x40(%rsp)
movsd  %xmm6,0x90(%rsp)
jmp    1279 <lowest+0x139>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
ucomisd %xmm2,%xmm3
ja     132f <lowest+0x1ef>
add    $0x1,%r14
mov    %ebp,%eax
add    %r14d,%eax
je     1328 <lowest+0x1e8>
movq   $0x0,0x0(%r13,%r14,8)
movsd  (%r9,%r14,8),%xmm3
movsd  (%rbx),%xmm2
movapd %xmm3,%xmm1
subsd  %xmm2,%xmm1
andpd  %xmm7,%xmm1
ucomisd %xmm1,%xmm5
jb     1260 <lowest+0x120>
ucomisd %xmm1,%xmm6
movapd %xmm4,%xmm2
jae    1300 <lowest+0x1c0>
divsd  %xmm0,%xmm1
cvttsd2si %xmm1,%edi
movapd %xmm8,0x60(%rsp)
call   1030 <fcube@plt>
mov    $0x1,%edi
sub    %eax,%edi
call   1030 <fcube@plt>
movsd  0xd40(%rip),%xmm4
movapd 0xd48(%rip),%xmm7
movsd  0x90(%rsp),%xmm6
movsd  0x40(%rsp),%xmm5
movapd 0x60(%rsp),%xmm8
movsd  0x50(%rsp),%xmm0
mov    0x30(%rsp),%r9
xorps  %xmm2,%xmm2
cvtsi2sd %eax,%xmm2
movsd  %xmm2,0x0(%r13,%r14,8)
test   %r12d,%r12d
je     131e <lowest+0x1de>
mov    0x38(%rsp),%rax
mulsd  (%rax,%r14,8),%xmm2
movsd  %xmm2,0x0(%r13,%r14,8)
addsd  %xmm2,%xmm8
jmp    126a <lowest+0x12a>
mov    0x8(%rsp),%rax
jmp    1337 <lowest+0x1f7>
add    0x14(%rsp),%r14d
mov    %r14d,%eax
xorpd  %xmm1,%xmm1
ucomisd %xmm8,%xmm1
mov    0x80(%rsp),%r14
mov    0xd8(%rsp),%rbx
mov    0xf0(%rsp),%r12
jae    157a <lowest+0x43a>
movl   $0x1,(%r12)
cmp    0x20(%rsp),%eax
mov    %rax,0x8(%rsp)
jle    1594 <lowest+0x454>
cltq
mov    %rax,%rcx
sub    %r15,%rcx
mov    %r15,%rdx
cmp    $0x2,%rcx
mov    0x18(%rsp),%rbp
jb     1420 <lowest+0x2e0>
mov    %rcx,%rdx
and    $0xfffffffffffffffe,%rdx
movapd %xmm8,%xmm3
unpcklpd %xmm8,%xmm3
lea    -0x2(%rdx),%rsi
mov    %rsi,%r8
shr    %r8
add    $0x1,%r8
test   %rsi,%rsi
je     1874 <lowest+0x734>
mov    %r8,%rsi
and    $0xfffffffffffffffe,%rsi
lea    (%rbx,%r15,8),%rbp
add    $0x8,%rbp
xor    %edi,%edi
mov    0x28(%rsp),%r10
nopl   (%rax)
movupd -0x10(%rbp,%rdi,8),%xmm1
movupd 0x0(%rbp,%rdi,8),%xmm2
divpd  %xmm3,%xmm1
movupd %xmm1,-0x10(%rbp,%rdi,8)
divpd  %xmm3,%xmm2
movupd %xmm2,0x0(%rbp,%rdi,8)
add    $0x4,%rdi
add    $0xfffffffffffffffe,%rsi
jne    13d0 <lowest+0x290>
test   $0x1,%r8b
je     1413 <lowest+0x2d3>
add    %r15,%rdi
movupd -0x8(%rbx,%rdi,8),%xmm1
divpd  %xmm3,%xmm1
movupd %xmm1,-0x8(%rbx,%rdi,8)
cmp    %rdx,%rcx
mov    0x18(%rsp),%rbp
je     144a <lowest+0x30a>
add    %r15,%rdx
mov    0x28(%rsp),%r10
cs nopw 0x0(%rax,%rax,1)
nop
movsd  -0x8(%rbx,%rdx,8),%xmm1
divsd  %xmm8,%xmm1
movsd  %xmm1,-0x8(%rbx,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%rax
jne    1430 <lowest+0x2f0>
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1793 <lowest+0x653>
mov    0x20(%rsp),%rdx
cmp    %edx,0x8(%rsp)
jle    15ac <lowest+0x46c>
mov    %r15,%rsi
not    %rsi
add    %rax,%rsi
xorpd  %xmm6,%xmm6
mov    %r15,%rdx
and    $0x3,%rcx
je     149a <lowest+0x35a>
nopl   (%rax)
movsd  -0x8(%rbx,%rdx,8),%xmm0
mulsd  -0x8(%rbp,%rdx,8),%xmm0
addsd  %xmm0,%xmm6
add    $0x1,%rdx
add    $0xffffffffffffffff,%rcx
jne    1480 <lowest+0x340>
cmp    $0x3,%rsi
jb     14e8 <lowest+0x3a8>
movsd  -0x8(%rbx,%rdx,8),%xmm0
movsd  (%rbx,%rdx,8),%xmm1
mulsd  -0x8(%rbp,%rdx,8),%xmm0
mulsd  0x0(%rbp,%rdx,8),%xmm1
addsd  %xmm6,%xmm0
movsd  0x8(%rbx,%rdx,8),%xmm2
mulsd  0x8(%rbp,%rdx,8),%xmm2
addsd  %xmm0,%xmm1
movsd  0x10(%rbx,%rdx,8),%xmm6
mulsd  0x10(%rbp,%rdx,8),%xmm6
addsd  %xmm1,%xmm2
addsd  %xmm2,%xmm6
add    $0x4,%rdx
cmp    %rdx,%rax
jne    14a0 <lowest+0x360>
movsd  (%r10),%xmm7
subsd  %xmm6,%xmm7
xorpd  %xmm2,%xmm2
mov    0x8(%rsp),%rax
cmp    0x20(%rsp),%eax
jle    15b9 <lowest+0x479>
movapd %xmm7,0x40(%rsp)
mov    %eax,%ebx
sub    0x14(%rsp),%ebx
xorpd  %xmm2,%xmm2
xor    %ebp,%ebp
movapd %xmm6,0x50(%rsp)
nopl   0x0(%rax)
movapd %xmm2,0x60(%rsp)
movsd  0x0(%r13,%rbp,8),%xmm0
movsd  %xmm0,0x38(%rsp)
movsd  (%r9,%rbp,8),%xmm0
subsd  %xmm6,%xmm0
call   1050 <fsquare@plt>
movapd 0x60(%rsp),%xmm2
movapd 0x50(%rsp),%xmm6
mov    0x30(%rsp),%r9
mulsd  0x38(%rsp),%xmm0
addsd  %xmm0,%xmm2
add    $0x1,%rbp
cmp    %ebp,%ebx
jne    1520 <lowest+0x3e0>
mov    0xd8(%rsp),%rbx
mov    0x18(%rsp),%rbp
movapd 0x40(%rsp),%xmm7
jmp    15b9 <lowest+0x479>
movl   $0x0,(%r12)
add    $0x98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
mov    0x18(%rsp),%rbp
mov    0x28(%rsp),%r10
jbe    1868 <lowest+0x728>
movsd  (%r10),%xmm7
xorpd  %xmm6,%xmm6
xorpd  %xmm2,%xmm2
xorpd  %xmm0,%xmm0
ucomisd %xmm0,%xmm2
jb     15cc <lowest+0x48c>
xorps  %xmm0,%xmm0
sqrtsd %xmm2,%xmm0
jmp    15fe <lowest+0x4be>
movapd %xmm2,%xmm0
movapd %xmm6,0x50(%rsp)
movapd %xmm7,0x40(%rsp)
movapd %xmm2,0x60(%rsp)
call   1060 <sqrt@plt>
movapd 0x60(%rsp),%xmm2
movapd 0x40(%rsp),%xmm7
movapd 0x50(%rsp),%xmm6
mov    0x30(%rsp),%r9
movsd  0x78(%rsp),%xmm1
mulsd  0x9fc(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1793 <lowest+0x653>
mov    0x20(%rsp),%rax
cmp    %eax,0x8(%rsp)
jle    1868 <lowest+0x728>
divsd  %xmm2,%xmm7
movslq 0x8(%rsp),%rax
mov    %rax,%rdx
sub    %r15,%rdx
mov    %r15,%rcx
cmp    $0x4,%rdx
jb     1702 <lowest+0x5c2>
lea    -0x8(,%rax,8),%rcx
ff
add    %rbp,%rcx
cmp    %rcx,%r13
jae    1665 <lowest+0x525>
lea    (%rbx,%rax,8),%rsi
add    $0xfffffffffffffff8,%rsi
mov    %r15,%rcx
cmp    %rsi,%r9
jb     1702 <lowest+0x5c2>
mov    %rdx,%rsi
and    $0xfffffffffffffffc,%rsi
lea    (%rsi,%r15,1),%rcx
movapd %xmm6,%xmm0
unpcklpd %xmm6,%xmm0
movapd %xmm7,%xmm1
unpcklpd %xmm7,%xmm1
lea    0x8(,%r15,8),%rdi
add    %rbp,%rdi
lea    (%rbx,%r15,8),%rbp
add    $0x8,%rbp
xor    %ebx,%ebx
movapd 0x993(%rip),%xmm2
nopl   (%rax)
movupd -0x10(%rdi,%rbx,8),%xmm3
movupd (%rdi,%rbx,8),%xmm4
subpd  %xmm0,%xmm3
subpd  %xmm0,%xmm4
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
mulpd  %xmm1,%xmm4
addpd  %xmm2,%xmm4
movupd -0x10(%rbp,%rbx,8),%xmm5
mulpd  %xmm3,%xmm5
movupd 0x0(%rbp,%rbx,8),%xmm3
mulpd  %xmm4,%xmm3
movupd %xmm5,-0x10(%rbp,%rbx,8)
movupd %xmm3,0x0(%rbp,%rbx,8)
add    $0x4,%rbx
cmp    %rbx,%rsi
jne    16a0 <lowest+0x560>
cmp    %rsi,%rdx
mov    0xd8(%rsp),%rbx
mov    0x18(%rsp),%rbp
je     1793 <lowest+0x653>
mov    0x8(%rsp),%rsi
sub    %ecx,%esi
mov    %rcx,%rdx
not    %rdx
test   $0x1,%sil
je     173b <lowest+0x5fb>
movsd  -0x8(%rbp,%rcx,8),%xmm0
subsd  %xmm6,%xmm0
mulsd  %xmm7,%xmm0
addsd  0x8e5(%rip),%xmm0
mulsd  -0x8(%rbx,%rcx,8),%xmm0
movsd  %xmm0,-0x8(%rbx,%rcx,8)
add    $0x1,%rcx
add    %rax,%rdx
je     1793 <lowest+0x653>
movsd  0x8c8(%rip),%xmm0
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%rbp,%rcx,8),%xmm1
subsd  %xmm6,%xmm1
mulsd  %xmm7,%xmm1
addsd  %xmm0,%xmm1
mulsd  -0x8(%rbx,%rcx,8),%xmm1
movsd  %xmm1,-0x8(%rbx,%rcx,8)
movsd  0x0(%rbp,%rcx,8),%xmm1
subsd  %xmm6,%xmm1
mulsd  %xmm7,%xmm1
addsd  %xmm0,%xmm1
mulsd  (%rbx,%rcx,8),%xmm1
movsd  %xmm1,(%rbx,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rax
jne    1750 <lowest+0x610>
movq   $0x0,(%r14)
mov    0x8(%rsp),%rsi
cmp    0x20(%rsp),%esi
mov    0x88(%rsp),%rdx
jle    1582 <lowest+0x442>
movslq %esi,%rax
sub    0x14(%rsp),%esi
mov    %r15,%rcx
not    %rcx
add    %rax,%rcx
xorpd  %xmm0,%xmm0
and    $0x3,%rsi
je     17f1 <lowest+0x6b1>
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%rbx,%r15,8),%xmm1
mulsd  -0x8(%rdx,%r15,8),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,(%r14)
add    $0x1,%r15
add    $0xffffffffffffffff,%rsi
jne    17d0 <lowest+0x690>
cmp    $0x3,%rcx
jb     1582 <lowest+0x442>
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%rbx,%r15,8),%xmm1
mulsd  -0x8(%rdx,%r15,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r14)
movsd  (%rbx,%r15,8),%xmm0
mulsd  (%rdx,%r15,8),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%r14)
movsd  0x8(%rbx,%r15,8),%xmm1
mulsd  0x8(%rdx,%r15,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r14)
movsd  0x10(%rbx,%r15,8),%xmm0
mulsd  0x10(%rdx,%r15,8),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%r14)
add    $0x4,%r15
cmp    %r15,%rax
jne    1800 <lowest+0x6c0>
jmp    1582 <lowest+0x442>
movq   $0x0,(%r14)
jmp    1582 <lowest+0x442>
xor    %edi,%edi
mov    0x28(%rsp),%r10
test   $0x1,%r8b
jne    1400 <lowest+0x2c0>
jmp    1413 <lowest+0x2d3>

LLVM IR (-O0):
define void @lowest(double* %0, double* %1, i32 %2, double* %3, double* %4, i32 %5, i32 %6, double* %7, i32 %8, double* %9, i32* %10) {
%12 = alloca double*
%13 = alloca double*
%14 = alloca i32
%15 = alloca double*
%16 = alloca double*
%17 = alloca i32
%18 = alloca i32
%19 = alloca double*
%20 = alloca i32
%21 = alloca double*
%22 = alloca i32*
%23 = alloca i32
%24 = alloca i32
%25 = alloca double
%26 = alloca double
%27 = alloca double
%28 = alloca double
%29 = alloca double
%30 = alloca double
%31 = alloca double
%32 = alloca double
store double* %0, double** %12
store double* %1, double** %13
store i32 %2, i32* %14
store double* %3, double** %15
store double* %4, double** %16
store i32 %5, i32* %17
store i32 %6, i32* %18
store double* %7, double** %19
store i32 %8, i32* %20
store double* %9, double** %21
store i32* %10, i32** %22
%33 = load double*, double** %12
%34 = getelementptr inbounds double, double* %33, i32 -1
store double* %34, double** %12
%35 = load double*, double** %13
%36 = getelementptr inbounds double, double* %35, i32 -1
store double* %36, double** %13
%37 = load double*, double** %19
%38 = getelementptr inbounds double, double* %37, i32 -1
store double* %38, double** %19
%39 = load double*, double** %21
%40 = getelementptr inbounds double, double* %39, i32 -1
store double* %40, double** %21
%41 = load double*, double** %12
%42 = load i32, i32* %14
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds double, double* %41, i64 %43
%45 = load double, double* %44
%46 = load double*, double** %12
%47 = getelementptr inbounds double, double* %46, i64 1
%48 = load double, double* %47
%49 = fsub double %45, %48
store double %49, double* %32
%50 = load double*, double** %15
%51 = load double, double* %50
%52 = load double*, double** %12
%53 = load i32, i32* %17
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds double, double* %52, i64 %54
%56 = load double, double* %55
%57 = fsub double %51, %56
%58 = load double*, double** %12
%59 = load i32, i32* %18
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds double, double* %58, i64 %60
%62 = load double, double* %61
%63 = load double*, double** %15
%64 = load double, double* %63
%65 = fsub double %62, %64
%66 = call double @fmax2(double %57, double %65)
store double %66, double* %28
%67 = load double, double* %28
%68 = fmul double 0x3FEFF7CED916872B, %67
store double %68, double* %30
%69 = load double, double* %28
%70 = fmul double 1.000000e-03, %69
store double %70, double* %29
store double 0.000000e+00, double* %25
%71 = load i32, i32* %17
store i32 %71, i32* %24
br label %72
72: ; preds = %151, %11
%73 = load i32, i32* %24
%74 = load i32, i32* %14
%75 = icmp sle i32 %73, %74
br i1 %75, label %76, label %154
76: ; preds = %72
%77 = load double*, double** %19
%78 = load i32, i32* %24
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds double, double* %77, i64 %79
store double 0.000000e+00, double* %80
%81 = load double*, double** %12
%82 = load i32, i32* %24
%83 = sext i32 %82 to i64
%84 = getelementptr inbounds double, double* %81, i64 %83
%85 = load double, double* %84
%86 = load double*, double** %15
%87 = load double, double* %86
%88 = fsub double %85, %87
%89 = call double @llvm.fabs.f64(double %88)
store double %89, double* %31
%90 = load double, double* %31
%91 = load double, double* %30
%92 = fcmp ole double %90, %91
br i1 %92, label %93, label %140
93: ; preds = %76
%94 = load double, double* %31
%95 = load double, double* %29
%96 = fcmp ole double %94, %95
br i1 %96, label %97, label %102
97: ; preds = %93
%98 = load double*, double** %19
%99 = load i32, i32* %24
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds double, double* %98, i64 %100
store double 1.000000e+00, double* %101
br label %117
102: ; preds = %93
%103 = load double, double* %31
%104 = load double, double* %28
%105 = fdiv double %103, %104
%106 = fptosi double %105 to i32
%107 = call i32 @fcube(i32 %106)
%108 = sitofp i32 %107 to double
%109 = fsub double 1.000000e+00, %108
%110 = fptosi double %109 to i32
%111 = call i32 @fcube(i32 %110)
%112 = sitofp i32 %111 to double
%113 = load double*, double** %19
%114 = load i32, i32* %24
%115 = sext i32 %114 to i64
%116 = getelementptr inbounds double, double* %113, i64 %115
store double %112, double* %116
br label %117
117: ; preds = %102, %97
%118 = load i32, i32* %20
%119 = icmp ne i32 %118, 0
br i1 %119, label %120, label %132
120: ; preds = %117
%121 = load double*, double** %21
%122 = load i32, i32* %24
%123 = sext i32 %122 to i64
%124 = getelementptr inbounds double, double* %121, i64 %123
%125 = load double, double* %124
%126 = load double*, double** %19
%127 = load i32, i32* %24
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds double, double* %126, i64 %128
%130 = load double, double* %129
%131 = fmul double %130, %125
store double %131, double* %129
br label %132
132: ; preds = %120, %117
%133 = load double*, double** %19
%134 = load i32, i32* %24
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds double, double* %133, i64 %135
%137 = load double, double* %136
%138 = load double, double* %25
%139 = fadd double %138, %137
store double %139, double* %25
br label %151
140: ; preds = %76
%141 = load double*, double** %12
%142 = load i32, i32* %24
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds double, double* %141, i64 %143
%145 = load double, double* %144
%146 = load double*, double** %15
%147 = load double, double* %146
%148 = fcmp ogt double %145, %147
br i1 %148, label %149, label %150
149: ; preds = %140
br label %154
150: ; preds = %140
br label %151
151: ; preds = %150, %132
%152 = load i32, i32* %24
%153 = add nsw i32 %152, 1
store i32 %153, i32* %24
br label %72
154: ; preds = %149, %72
%155 = load i32, i32* %24
%156 = sub nsw i32 %155, 1
store i32 %156, i32* %23
%157 = load double, double* %25
%158 = fcmp ole double %157, 0.000000e+00
br i1 %158, label %159, label %161
159: ; preds = %154
%160 = load i32*, i32** %22
store i32 0, i32* %160
br label %294
161: ; preds = %154
%162 = load i32*, i32** %22
store i32 1, i32* %162
%163 = load i32, i32* %17
store i32 %163, i32* %24
br label %164
164: ; preds = %176, %161
%165 = load i32, i32* %24
%166 = load i32, i32* %23
%167 = icmp sle i32 %165, %166
br i1 %167, label %168, label %179
168: ; preds = %164
%169 = load double, double* %25
%170 = load double*, double** %19
%171 = load i32, i32* %24
%172 = sext i32 %171 to i64
%173 = getelementptr inbounds double, double* %170, i64 %172
%174 = load double, double* %173
%175 = fdiv double %174, %169
store double %175, double* %173
br label %176
176: ; preds = %168
%177 = load i32, i32* %24
%178 = add nsw i32 %177, 1
store i32 %178, i32* %24
br label %164
179: ; preds = %164
%180 = load double, double* %28
%181 = fcmp ogt double %180, 0.000000e+00
br i1 %181, label %182, label %269
182: ; preds = %179
store double 0.000000e+00, double* %25
%183 = load i32, i32* %17
store i32 %183, i32* %24
br label %184
184: ; preds = %201, %182
%185 = load i32, i32* %24
%186 = load i32, i32* %23
%187 = icmp sle i32 %185, %186
br i1 %187, label %188, label %204
188: ; preds = %184
%189 = load double*, double** %19
%190 = load i32, i32* %24
%191 = sext i32 %190 to i64
%192 = getelementptr inbounds double, double* %189, i64 %191
%193 = load double, double* %192
%194 = load double*, double** %12
%195 = load i32, i32* %24
%196 = sext i32 %195 to i64
%197 = getelementptr inbounds double, double* %194, i64 %196
%198 = load double, double* %197
%199 = load double, double* %25
%200 = call double @llvm.fmuladd.f64(double %193, double %198, double %199)
store double %200, double* %25
br label %201
201: ; preds = %188
%202 = load i32, i32* %24
%203 = add nsw i32 %202, 1
store i32 %203, i32* %24
br label %184
204: ; preds = %184
%205 = load double*, double** %15
%206 = load double, double* %205
%207 = load double, double* %25
%208 = fsub double %206, %207
store double %208, double* %26
store double 0.000000e+00, double* %27
%209 = load i32, i32* %17
store i32 %209, i32* %24
br label %210
210: ; preds = %230, %204
%211 = load i32, i32* %24
%212 = load i32, i32* %23
%213 = icmp sle i32 %211, %212
br i1 %213, label %214, label %233
214: ; preds = %210
%215 = load double*, double** %19
%216 = load i32, i32* %24
%217 = sext i32 %216 to i64
%218 = getelementptr inbounds double, double* %215, i64 %217
%219 = load double, double* %218
%220 = load double*, double** %12
%221 = load i32, i32* %24
%222 = sext i32 %221 to i64
%223 = getelementptr inbounds double, double* %220, i64 %222
%224 = load double, double* %223
%225 = load double, double* %25
%226 = fsub double %224, %225
%227 = call double @fsquare(double %226)
%228 = load double, double* %27
%229 = call double @llvm.fmuladd.f64(double %219, double %227, double %228)
store double %229, double* %27
br label %230
230: ; preds = %214
%231 = load i32, i32* %24
%232 = add nsw i32 %231, 1
store i32 %232, i32* %24
br label %210
233: ; preds = %210
%234 = load double, double* %27
%235 = call double @sqrt(double %234)
%236 = load double, double* %32
%237 = fmul double 1.000000e-03, %236
%238 = fcmp ogt double %235, %237
br i1 %238, label %239, label %268
239: ; preds = %233
%240 = load double, double* %27
%241 = load double, double* %26
%242 = fdiv double %241, %240
store double %242, double* %26
%243 = load i32, i32* %17
store i32 %243, i32* %24
br label %244
244: ; preds = %264, %239
%245 = load i32, i32* %24
%246 = load i32, i32* %23
%247 = icmp sle i32 %245, %246
br i1 %247, label %248, label %267
248: ; preds = %244
%249 = load double, double* %26
%250 = load double*, double** %12
%251 = load i32, i32* %24
%252 = sext i32 %251 to i64
%253 = getelementptr inbounds double, double* %250, i64 %252
%254 = load double, double* %253
%255 = load double, double* %25
%256 = fsub double %254, %255
%257 = call double @llvm.fmuladd.f64(double %249, double %256, double 1.000000e+00)
%258 = load double*, double** %19
%259 = load i32, i32* %24
%260 = sext i32 %259 to i64
%261 = getelementptr inbounds double, double* %258, i64 %260
%262 = load double, double* %261
%263 = fmul double %262, %257
store double %263, double* %261
br label %264
264: ; preds = %248
%265 = load i32, i32* %24
%266 = add nsw i32 %265, 1
store i32 %266, i32* %24
br label %244
267: ; preds = %244
br label %268
268: ; preds = %267, %233
br label %269
269: ; preds = %268, %179
%270 = load double*, double** %16
store double 0.000000e+00, double* %270
%271 = load i32, i32* %17
store i32 %271, i32* %24
br label %272
272: ; preds = %290, %269
%273 = load i32, i32* %24
%274 = load i32, i32* %23
%275 = icmp sle i32 %273, %274
br i1 %275, label %276, label %293
276: ; preds = %272
%277 = load double*, double** %19
%278 = load i32, i32* %24
%279 = sext i32 %278 to i64
%280 = getelementptr inbounds double, double* %277, i64 %279
%281 = load double, double* %280
%282 = load double*, double** %13
%283 = load i32, i32* %24
%284 = sext i32 %283 to i64
%285 = getelementptr inbounds double, double* %282, i64 %284
%286 = load double, double* %285
%287 = load double*, double** %16
%288 = load double, double* %287
%289 = call double @llvm.fmuladd.f64(double %281, double %286, double %288)
store double %289, double* %287
br label %290
290: ; preds = %276
%291 = load i32, i32* %24
%292 = add nsw i32 %291, 1
store i32 %292, i32* %24
br label %272
293: ; preds = %272
br label %294
294: ; preds = %293, %159
ret void
}

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