#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 PartialFixedLB(int, double, double, double, double, double, double,
                      double);
int /*<<< orphan*/ abort();
int /*<<< orphan*/ assert(int);
double cbnd(double, double, double);
double cnd(double);
double exp(double);
double fmax(double, double);
double fmin(double, double);
double log(double);
double pow(double, double);
double sqrt(double);
double LookBarrier(int type, double S, double X, double H, double t1, double T2,
                   double r, double b, double v) {
  double vst1, vv, erT2, vsT2, hh, K, mu1, mu2, Rho, eta, m;
  double emu2hv, emu1hv, g1, g2, ta, tb, trho, tp1, tp2, part1, part2, part3,
      part4;
  double OutValue, result;
  assert(((S) == (S)) && (S) >= 0.000001 && (S) <= 1000000000000.0);
  assert(((X) == (X)) && (X) >= 0.000001 && (X) <= 1000000000000.0);
  assert(((r) == (r)) && (r) >= 0.0 && (r) <= 1000.0);
  assert(((b) == (b)) && (b) >= -1000.0 && (b) <= 1000.0);
  assert(((v) == (v)) && (v) >= 0.0000001 && v <= 100.99999);
  assert(((t1) == (t1)));
  assert(((T2) == (T2)));
  assert(type == 4 || type == 6 || type == 3 || type == 5);
  vst1 = v * sqrt(t1);
  assert(((vst1) == (vst1)));
  vv = v * v;
  erT2 = exp(-r * T2);
  vsT2 = v * sqrt(T2);
  hh = log(H / S);
  K = log(X / S);
  mu1 = b - vv / 2.0;
  mu2 = b + vv / 2.0;
  assert(((mu2) == (mu2)));
  Rho = sqrt(t1 / T2);
  if (type == 4 || type == 3) {
    eta = 1.0;
    m = fmin(hh, K);
  } else if (type == 6 || type == 5) {
    eta = -1.0;
    m = fmax(hh, K);
  } else
    abort();
  emu2hv = exp(2.0 * mu2 * hh / vv);
  emu1hv = exp(2.0 * mu1 * hh / vv);
  g1 = (cnd(eta * (hh - mu2 * t1) / vst1) -
        emu2hv * cnd(eta * (-hh - mu2 * t1) / vst1)) -
       (cnd(eta * (m - mu2 * t1) / vst1) -
        emu2hv * cnd(eta * (m - 2.0 * hh - mu2 * t1) / vst1));
  g2 = (cnd(eta * (hh - mu1 * t1) / vst1) -
        emu1hv * cnd(eta * (-hh - mu1 * t1) / vst1)) -
       (cnd(eta * (m - mu1 * t1) / vst1) -
        emu1hv * cnd(eta * (m - 2.0 * hh - mu1 * t1) / vst1));
  ta = eta * (m - mu2 * t1) / vst1;
  assert(((ta) == (ta)));
  tb = eta * (-K + mu2 * T2) / vsT2;
  assert(((tb) == (tb)));
  trho = -Rho;
  assert(((trho) == (trho)));
  tp1 = cbnd(ta, tb, trho);
  ta = eta * (m - 2.0 * hh - mu2 * t1) / vst1;
  assert(((ta) == (ta)));
  tb = eta * (2.0 * hh - K + mu2 * T2) / vsT2;
  assert(((tb) == (tb)));
  tp2 = cbnd(ta, tb, trho);
  assert(((tp2) == (tp2)));
  part1 = S * exp((b - r) * T2) * (1.0 + vv / (2.0 * b)) * (tp1 - emu2hv * tp2);
  part2 =
      -erT2 * X *
      (cbnd(eta * (m - mu1 * t1) / vst1, eta * (-K + mu1 * T2) / vsT2, -Rho) -
       emu1hv * cbnd(eta * (m - 2.0 * hh - mu1 * t1) / vst1,
                     eta * (2.0 * hh - K + mu1 * T2) / vsT2, -Rho));
  part3 = -erT2 * vv / (2.0 * b) *
          (S * pow(S / X, -2.0 * b / vv) *
               cbnd(eta * (m + mu1 * t1) / vst1, eta * (-K - mu1 * T2) / vsT2,
                    -Rho) -
           H * pow(H / X, -2.0 * b / vv) *
               cbnd(eta * (m - 2.0 * hh + mu1 * t1) / vst1,
                    eta * (2.0 * hh - K - mu1 * T2) / vsT2, -Rho));
  part4 = S * exp((b - r) * T2) *
              ((1.0 + vv / (2.0 * b)) *
                   cnd(eta * mu2 * (T2 - t1) / (v * sqrt(T2 - t1))) +
               exp(-b * (T2 - t1)) * (1.0 - vv / (2.0 * b)) *
                   cnd(eta * (-mu1 * (T2 - t1)) / (v * sqrt(T2 - t1)))) *
              g1 -
          erT2 * X * g2;
  OutValue = eta * (part1 + part2 + part3 + part4);
  if (type == 4 || type == 6)
    result = OutValue;
  else if (type == 3)
    result = PartialFixedLB(1, S, X, t1, T2, r, b, v) - OutValue;
  else if (type == 5)
    result = PartialFixedLB(0, S, X, t1, T2, r, b, v) - OutValue;
  else
    abort();
  return result;
}


x86 assembly (clang, -O0):
<LookBarrier>:
push   %rbp
mov    %rsp,%rbp
sub    $0x220,%rsp
mov    %edi,-0x4(%rbp)
movsd  %xmm0,-0x10(%rbp)
movsd  %xmm1,-0x18(%rbp)
movsd  %xmm2,-0x20(%rbp)
movsd  %xmm3,-0x28(%rbp)
movsd  %xmm4,-0x30(%rbp)
movsd  %xmm5,-0x38(%rbp)
movsd  %xmm6,-0x40(%rbp)
movsd  %xmm7,-0x48(%rbp)
movsd  -0x10(%rbp),%xmm0
xor    %eax,%eax
ucomisd -0x10(%rbp),%xmm0
mov    %al,-0x119(%rbp)
jne    1219 <LookBarrier+0x89>
jp     1219 <LookBarrier+0x89>
movsd  -0x10(%rbp),%xmm0
xor    %eax,%eax
movsd  0x1e0d(%rip),%xmm1
ucomisd %xmm1,%xmm0
mov    %al,-0x119(%rbp)
jb     1219 <LookBarrier+0x89>
movsd  0x1dfd(%rip),%xmm0
ucomisd -0x10(%rbp),%xmm0
setae  %al
mov    %al,-0x119(%rbp)
mov    -0x119(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
movsd  -0x18(%rbp),%xmm0
xor    %eax,%eax
ucomisd -0x18(%rbp),%xmm0
mov    %al,-0x11a(%rbp)
jne    127c <LookBarrier+0xec>
jp     127c <LookBarrier+0xec>
movsd  -0x18(%rbp),%xmm0
xor    %eax,%eax
movsd  0x1daa(%rip),%xmm1
ucomisd %xmm1,%xmm0
mov    %al,-0x11a(%rbp)
jb     127c <LookBarrier+0xec>
movsd  0x1d9a(%rip),%xmm0
ucomisd -0x18(%rbp),%xmm0
setae  %al
mov    %al,-0x11a(%rbp)
mov    -0x11a(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
movsd  -0x38(%rbp),%xmm0
xor    %eax,%eax
ucomisd -0x38(%rbp),%xmm0
mov    %al,-0x11b(%rbp)
jne    12da <LookBarrier+0x14a>
jp     12da <LookBarrier+0x14a>
movsd  -0x38(%rbp),%xmm0
xor    %eax,%eax
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
mov    %al,-0x11b(%rbp)
jb     12da <LookBarrier+0x14a>
movsd  0x1d44(%rip),%xmm0
ucomisd -0x38(%rbp),%xmm0
setae  %al
mov    %al,-0x11b(%rbp)
mov    -0x11b(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
movsd  -0x40(%rbp),%xmm0
xor    %eax,%eax
ucomisd -0x40(%rbp),%xmm0
mov    %al,-0x11c(%rbp)
jne    133d <LookBarrier+0x1ad>
jp     133d <LookBarrier+0x1ad>
movsd  -0x40(%rbp),%xmm0
xor    %eax,%eax
movsd  0x1d01(%rip),%xmm1
ucomisd %xmm1,%xmm0
mov    %al,-0x11c(%rbp)
jb     133d <LookBarrier+0x1ad>
movsd  0x1ce1(%rip),%xmm0
ucomisd -0x40(%rbp),%xmm0
setae  %al
mov    %al,-0x11c(%rbp)
mov    -0x11c(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
movsd  -0x48(%rbp),%xmm0
xor    %eax,%eax
ucomisd -0x48(%rbp),%xmm0
mov    %al,-0x11d(%rbp)
jne    13a0 <LookBarrier+0x210>
jp     13a0 <LookBarrier+0x210>
movsd  -0x48(%rbp),%xmm0
xor    %eax,%eax
movsd  0x1ca6(%rip),%xmm1
ucomisd %xmm1,%xmm0
mov    %al,-0x11d(%rbp)
jb     13a0 <LookBarrier+0x210>
movsd  0x1c96(%rip),%xmm0
ucomisd -0x48(%rbp),%xmm0
setae  %al
mov    %al,-0x11d(%rbp)
mov    -0x11d(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
movsd  -0x28(%rbp),%xmm0
ucomisd -0x28(%rbp),%xmm0
sete   %al
setnp  %cl
and    %cl,%al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
movsd  -0x30(%rbp),%xmm0
ucomisd -0x30(%rbp),%xmm0
sete   %al
setnp  %cl
and    %cl,%al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
mov    $0x1,%al
cmpl   $0x4,-0x4(%rbp)
mov    %al,-0x11e(%rbp)
je     142b <LookBarrier+0x29b>
mov    $0x1,%al
cmpl   $0x6,-0x4(%rbp)
mov    %al,-0x11e(%rbp)
je     142b <LookBarrier+0x29b>
mov    $0x1,%al
cmpl   $0x3,-0x4(%rbp)
mov    %al,-0x11e(%rbp)
je     142b <LookBarrier+0x29b>
cmpl   $0x5,-0x4(%rbp)
sete   %al
mov    %al,-0x11e(%rbp)
mov    -0x11e(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
movsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x28(%rbp),%xmm0
call   10b0 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0x130(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
ucomisd -0x50(%rbp),%xmm0
sete   %al
setnp  %cl
and    %cl,%al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
movsd  -0x48(%rbp),%xmm0
mulsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x38(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x30(%rbp),%xmm0
call   1070 <exp@plt>
movsd  %xmm0,-0x60(%rbp)
movsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x30(%rbp),%xmm0
call   10b0 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0x128(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x20(%rbp),%xmm0
divsd  -0x10(%rbp),%xmm0
call   1080 <log@plt>
movsd  %xmm0,-0x70(%rbp)
movsd  -0x18(%rbp),%xmm0
divsd  -0x10(%rbp),%xmm0
call   1080 <log@plt>
movsd  %xmm0,-0x78(%rbp)
movsd  -0x40(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm1
movsd  0x1b0f(%rip),%xmm2
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x40(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm1
movsd  0x1af0(%rip),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
ucomisd -0x88(%rbp),%xmm0
ff
sete   %al
setnp  %cl
and    %cl,%al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
movsd  -0x28(%rbp),%xmm0
divsd  -0x30(%rbp),%xmm0
call   10b0 <sqrt@plt>
movsd  %xmm0,-0x90(%rbp)
ff
cmpl   $0x4,-0x4(%rbp)
je     159d <LookBarrier+0x40d>
cmpl   $0x3,-0x4(%rbp)
jne    15e2 <LookBarrier+0x452>
movsd  0x1a9b(%rip),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x70(%rbp),%xmm3
movsd  -0x78(%rbp),%xmm2
movaps %xmm2,%xmm4
movaps %xmm3,%xmm0
cmpunordsd %xmm0,%xmm0
movaps %xmm0,%xmm1
pand   %xmm4,%xmm1
minsd  %xmm3,%xmm2
pandn  %xmm2,%xmm0
por    %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
jmp    1647 <LookBarrier+0x4b7>
cmpl   $0x6,-0x4(%rbp)
je     15f6 <LookBarrier+0x466>
cmpl   $0x5,-0x4(%rbp)
jne    163b <LookBarrier+0x4ab>
movsd  0x1a3a(%rip),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x70(%rbp),%xmm3
movsd  -0x78(%rbp),%xmm2
movaps %xmm2,%xmm4
movaps %xmm3,%xmm0
cmpunordsd %xmm0,%xmm0
movaps %xmm0,%xmm1
pand   %xmm4,%xmm1
maxsd  %xmm3,%xmm2
pandn  %xmm2,%xmm0
por    %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
jmp    1642 <LookBarrier+0x4b2>
mov    $0x0,%al
call   1030 <abort@plt>
jmp    1647 <LookBarrier+0x4b7>
movsd  0x19e1(%rip),%xmm0
mulsd  -0x88(%rbp),%xmm0
ff
mulsd  -0x70(%rbp),%xmm0
divsd  -0x58(%rbp),%xmm0
call   1070 <exp@plt>
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  0x19ba(%rip),%xmm0
mulsd  -0x80(%rbp),%xmm0
mulsd  -0x70(%rbp),%xmm0
divsd  -0x58(%rbp),%xmm0
call   1070 <exp@plt>
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0x70(%rbp),%xmm2
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0x28(%rbp),%xmm3
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
divsd  -0x50(%rbp),%xmm0
call   1090 <cnd@plt>
movsd  %xmm0,-0x218(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x210(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0x70(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0x28(%rbp),%xmm3
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
divsd  -0x50(%rbp),%xmm0
call   1090 <cnd@plt>
movsd  -0x218(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x210(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1f8(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0x28(%rbp),%xmm3
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
divsd  -0x50(%rbp),%xmm0
call   1090 <cnd@plt>
movsd  %xmm0,-0x200(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x208(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0x70(%rbp),%xmm1
addsd  %xmm1,%xmm1
subsd  %xmm1,%xmm2
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0x28(%rbp),%xmm3
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
divsd  -0x50(%rbp),%xmm0
call   1090 <cnd@plt>
movsd  -0x208(%rbp),%xmm1
ff
movsd  -0x200(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0x1f8(%rbp),%xmm0
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0x70(%rbp),%xmm2
movsd  -0x80(%rbp),%xmm1
movsd  -0x28(%rbp),%xmm3
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
divsd  -0x50(%rbp),%xmm0
call   1090 <cnd@plt>
movsd  %xmm0,-0x1f0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0x1e8(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0x70(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
movsd  -0x80(%rbp),%xmm1
movsd  -0x28(%rbp),%xmm3
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
divsd  -0x50(%rbp),%xmm0
call   1090 <cnd@plt>
movsd  -0x1f0(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x1e8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1d0(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0x80(%rbp),%xmm1
movsd  -0x28(%rbp),%xmm3
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
divsd  -0x50(%rbp),%xmm0
call   1090 <cnd@plt>
movsd  %xmm0,-0x1d8(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0x1e0(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0x70(%rbp),%xmm1
addsd  %xmm1,%xmm1
subsd  %xmm1,%xmm2
movsd  -0x80(%rbp),%xmm1
movsd  -0x28(%rbp),%xmm3
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
divsd  -0x50(%rbp),%xmm0
call   1090 <cnd@plt>
movsd  -0x1e0(%rbp),%xmm1
ff
movsd  -0x1d8(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0x1d0(%rbp),%xmm0
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0x28(%rbp),%xmm3
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
divsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
ucomisd -0xc8(%rbp),%xmm0
ff
sete   %al
setnp  %cl
and    %cl,%al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0x78(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0x30(%rbp),%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
divsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
ucomisd -0xd0(%rbp),%xmm0
ff
sete   %al
setnp  %cl
and    %cl,%al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
movsd  -0x90(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
ucomisd -0xd8(%rbp),%xmm0
ff
sete   %al
setnp  %cl
and    %cl,%al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
movsd  -0xc8(%rbp),%xmm0
ff
movsd  -0xd0(%rbp),%xmm1
ff
movsd  -0xd8(%rbp),%xmm2
ff
call   1040 <cbnd@plt>
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0x70(%rbp),%xmm1
addsd  %xmm1,%xmm1
subsd  %xmm1,%xmm2
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0x28(%rbp),%xmm3
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
divsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
ucomisd -0xc8(%rbp),%xmm0
ff
sete   %al
setnp  %cl
and    %cl,%al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0x70(%rbp),%xmm2
movsd  -0x78(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
addsd  %xmm2,%xmm2
addsd  %xmm1,%xmm2
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0x30(%rbp),%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
divsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
ucomisd -0xd0(%rbp),%xmm0
ff
sete   %al
setnp  %cl
and    %cl,%al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
movsd  -0xc8(%rbp),%xmm0
ff
movsd  -0xd0(%rbp),%xmm1
ff
movsd  -0xd8(%rbp),%xmm2
ff
call   1040 <cbnd@plt>
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
ucomisd -0xe8(%rbp),%xmm0
ff
sete   %al
setnp  %cl
and    %cl,%al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
movsd  -0x10(%rbp),%xmm0
movsd  %xmm0,-0x1c8(%rbp)
ff
movsd  -0x40(%rbp),%xmm0
subsd  -0x38(%rbp),%xmm0
mulsd  -0x30(%rbp),%xmm0
call   1070 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0x1c8(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  -0x58(%rbp),%xmm2
movsd  0x12fc(%rip),%xmm1
mulsd  -0x40(%rbp),%xmm1
divsd  %xmm1,%xmm2
movsd  0x12fb(%rip),%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  -0xe0(%rbp),%xmm2
ff
movsd  -0xa8(%rbp),%xmm1
ff
movsd  -0xe8(%rbp),%xmm3
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x18(%rbp),%xmm0
movsd  %xmm0,-0x1b0(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0x80(%rbp),%xmm1
movsd  -0x28(%rbp),%xmm3
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
divsd  -0x50(%rbp),%xmm0
movsd  -0x98(%rbp),%xmm1
ff
movsd  -0x78(%rbp),%xmm2
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
movsd  -0x80(%rbp),%xmm2
movsd  -0x30(%rbp),%xmm4
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
divsd  -0x68(%rbp),%xmm1
movsd  -0x90(%rbp),%xmm2
ff
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
call   1040 <cbnd@plt>
movsd  %xmm0,-0x1b8(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0x1c0(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0x70(%rbp),%xmm1
addsd  %xmm1,%xmm1
subsd  %xmm1,%xmm2
movsd  -0x80(%rbp),%xmm1
movsd  -0x28(%rbp),%xmm3
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
divsd  -0x50(%rbp),%xmm0
movsd  -0x98(%rbp),%xmm1
ff
movsd  -0x70(%rbp),%xmm3
movsd  -0x78(%rbp),%xmm2
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
addsd  %xmm3,%xmm3
addsd  %xmm2,%xmm3
movsd  -0x80(%rbp),%xmm2
movsd  -0x30(%rbp),%xmm4
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
divsd  -0x68(%rbp),%xmm1
movsd  -0x90(%rbp),%xmm2
ff
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
call   1040 <cbnd@plt>
movsd  -0x1c0(%rbp),%xmm1
ff
movsd  -0x1b8(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0x1b0(%rbp),%xmm0
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x58(%rbp),%xmm0
movsd  0x108c(%rip),%xmm1
mulsd  -0x40(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x180(%rbp)
ff
movsd  -0x10(%rbp),%xmm0
movsd  %xmm0,-0x1a8(%rbp)
ff
movsd  -0x10(%rbp),%xmm0
divsd  -0x18(%rbp),%xmm0
movsd  0x1074(%rip),%xmm1
mulsd  -0x40(%rbp),%xmm1
divsd  -0x58(%rbp),%xmm1
call   10a0 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x1a8(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x190(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
movsd  -0xa0(%rbp),%xmm2
movsd  -0x80(%rbp),%xmm1
movsd  -0x28(%rbp),%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
divsd  -0x50(%rbp),%xmm0
movsd  -0x98(%rbp),%xmm1
ff
movsd  -0x78(%rbp),%xmm2
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
movsd  -0x80(%rbp),%xmm2
movsd  -0x30(%rbp),%xmm4
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
divsd  -0x68(%rbp),%xmm1
movsd  -0x90(%rbp),%xmm2
ff
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
call   1040 <cbnd@plt>
movsd  %xmm0,-0x188(%rbp)
ff
movsd  -0x20(%rbp),%xmm0
movsd  %xmm0,-0x1a0(%rbp)
ff
movsd  -0x20(%rbp),%xmm0
divsd  -0x18(%rbp),%xmm0
movsd  0xf82(%rip),%xmm1
mulsd  -0x40(%rbp),%xmm1
divsd  -0x58(%rbp),%xmm1
call   10a0 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x1a0(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x198(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0x70(%rbp),%xmm1
addsd  %xmm1,%xmm1
subsd  %xmm1,%xmm2
movsd  -0x80(%rbp),%xmm1
movsd  -0x28(%rbp),%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
divsd  -0x50(%rbp),%xmm0
movsd  -0x98(%rbp),%xmm1
ff
movsd  -0x70(%rbp),%xmm3
movsd  -0x78(%rbp),%xmm2
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
addsd  %xmm3,%xmm3
addsd  %xmm2,%xmm3
movsd  -0x80(%rbp),%xmm2
movsd  -0x30(%rbp),%xmm4
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
divsd  -0x68(%rbp),%xmm1
movsd  -0x90(%rbp),%xmm2
ff
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
call   1040 <cbnd@plt>
movsd  -0x198(%rbp),%xmm2
ff
movsd  -0x190(%rbp),%xmm1
ff
movsd  -0x188(%rbp),%xmm3
ff
movaps %xmm0,%xmm4
movsd  -0x180(%rbp),%xmm0
ff
mulsd  %xmm4,%xmm2
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
movsd  -0x10(%rbp),%xmm0
movsd  %xmm0,-0x178(%rbp)
ff
movsd  -0x40(%rbp),%xmm0
subsd  -0x38(%rbp),%xmm0
mulsd  -0x30(%rbp),%xmm0
call   1070 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0x178(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0x58(%rbp),%xmm1
movsd  0xdee(%rip),%xmm0
mulsd  -0x40(%rbp),%xmm0
divsd  %xmm0,%xmm1
movsd  0xded(%rip),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
mulsd  -0x88(%rbp),%xmm0
ff
movsd  -0x30(%rbp),%xmm1
subsd  -0x28(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x168(%rbp)
ff
movsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x170(%rbp)
ff
movsd  -0x30(%rbp),%xmm0
subsd  -0x28(%rbp),%xmm0
call   10b0 <sqrt@plt>
movsd  -0x170(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x168(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
call   1090 <cnd@plt>
movsd  %xmm0,-0x140(%rbp)
ff
movsd  -0x40(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x30(%rbp),%xmm1
subsd  -0x28(%rbp),%xmm1
mulsd  %xmm1,%xmm0
call   1070 <exp@plt>
movsd  -0x58(%rbp),%xmm2
movsd  0xd2b(%rip),%xmm1
mulsd  -0x40(%rbp),%xmm1
divsd  %xmm1,%xmm2
movsd  0xd2a(%rip),%xmm1
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0x80(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  -0x30(%rbp),%xmm2
subsd  -0x28(%rbp),%xmm2
mulsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
movsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
movsd  -0x30(%rbp),%xmm0
subsd  -0x28(%rbp),%xmm0
call   10b0 <sqrt@plt>
movsd  -0x160(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x158(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
call   1090 <cnd@plt>
movsd  -0x150(%rbp),%xmm2
ff
movsd  -0x148(%rbp),%xmm1
ff
movsd  -0x140(%rbp),%xmm3
ff
movaps %xmm0,%xmm4
movsd  -0x138(%rbp),%xmm0
ff
mulsd  %xmm4,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  -0xb8(%rbp),%xmm2
ff
movsd  -0x60(%rbp),%xmm1
mulsd  -0x18(%rbp),%xmm1
mulsd  -0xc0(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0xf0(%rbp),%xmm1
ff
addsd  -0xf8(%rbp),%xmm1
ff
addsd  -0x100(%rbp),%xmm1
ff
addsd  -0x108(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
cmpl   $0x4,-0x4(%rbp)
je     245c <LookBarrier+0x12cc>
cmpl   $0x6,-0x4(%rbp)
jne    2471 <LookBarrier+0x12e1>
movsd  -0x110(%rbp),%xmm0
ff
movsd  %xmm0,-0x118(%rbp)
ff
jmp    2517 <LookBarrier+0x1387>
cmpl   $0x3,-0x4(%rbp)
jne    24bd <LookBarrier+0x132d>
movsd  -0x10(%rbp),%xmm0
movsd  -0x18(%rbp),%xmm1
movsd  -0x28(%rbp),%xmm2
movsd  -0x30(%rbp),%xmm3
movsd  -0x38(%rbp),%xmm4
movsd  -0x40(%rbp),%xmm5
movsd  -0x48(%rbp),%xmm6
mov    $0x1,%edi
call   1060 <PartialFixedLB@plt>
subsd  -0x110(%rbp),%xmm0
ff
movsd  %xmm0,-0x118(%rbp)
ff
jmp    2512 <LookBarrier+0x1382>
cmpl   $0x5,-0x4(%rbp)
jne    2506 <LookBarrier+0x1376>
movsd  -0x10(%rbp),%xmm0
movsd  -0x18(%rbp),%xmm1
movsd  -0x28(%rbp),%xmm2
movsd  -0x30(%rbp),%xmm3
movsd  -0x38(%rbp),%xmm4
movsd  -0x40(%rbp),%xmm5
movsd  -0x48(%rbp),%xmm6
xor    %edi,%edi
call   1060 <PartialFixedLB@plt>
subsd  -0x110(%rbp),%xmm0
ff
movsd  %xmm0,-0x118(%rbp)
jmp    250d <LookBarrier+0x137d>
mov    $0x0,%al
call   1030 <abort@plt>
jmp    2512 <LookBarrier+0x1382>
jmp    2517 <LookBarrier+0x1387>
movsd  -0x118(%rbp),%xmm0
ff
add    $0x220,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<LookBarrier>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x230,%rsp
ucomisd %xmm0,%xmm0
setnp  %al
ucomisd 0xe52(%rip),%xmm0
setae  %cl
and    %al,%cl
movsd  0xe4c(%rip),%xmm8
movsd  %xmm0,0x30(%rsp)
ucomisd %xmm0,%xmm8
movsd  %xmm7,0x38(%rsp)
movaps %xmm6,0xe0(%rsp)
movaps %xmm5,0x170(%rsp)
movaps %xmm4,0x90(%rsp)
movaps %xmm3,0xb0(%rsp)
movsd  %xmm2,0x108(%rsp)
movaps %xmm1,0x150(%rsp)
mov    %edi,%r15d
setae  %al
and    %cl,%al
movzbl %al,%edi
call   1050 <assert@plt>
movapd 0x150(%rsp),%xmm1
ucomisd %xmm1,%xmm1
setnp  %al
ucomisd 0xdda(%rip),%xmm1
setae  %cl
and    %al,%cl
movsd  0xdd5(%rip),%xmm0
ucomisd %xmm1,%xmm0
setae  %al
and    %cl,%al
movzbl %al,%edi
call   1050 <assert@plt>
xorpd  %xmm0,%xmm0
movapd 0x170(%rsp),%xmm1
ucomisd %xmm0,%xmm1
setae  %al
movsd  0xdb0(%rip),%xmm0
ucomisd %xmm1,%xmm0
setae  %cl
and    %al,%cl
movzbl %cl,%edi
call   1050 <assert@plt>
movapd 0xe0(%rsp),%xmm0
ucomisd %xmm0,%xmm0
setnp  %al
ucomisd 0xd8f(%rip),%xmm0
setae  %cl
and    %al,%cl
movsd  0xd7a(%rip),%xmm1
ucomisd %xmm0,%xmm1
setae  %al
and    %cl,%al
movzbl %al,%edi
call   1050 <assert@plt>
movsd  0x38(%rsp),%xmm1
ucomisd %xmm1,%xmm1
setnp  %al
ucomisd 0xd64(%rip),%xmm1
setae  %cl
and    %al,%cl
movsd  0xd5f(%rip),%xmm0
ucomisd %xmm1,%xmm0
setae  %al
and    %cl,%al
movzbl %al,%edi
call   1050 <assert@plt>
xor    %edi,%edi
movapd 0xb0(%rsp),%xmm0
ucomisd %xmm0,%xmm0
setnp  %dil
call   1050 <assert@plt>
xor    %edi,%edi
movapd 0x90(%rsp),%xmm0
ucomisd %xmm0,%xmm0
setnp  %dil
call   1050 <assert@plt>
mov    %r15d,%r14d
and    $0xfffffffd,%r14d
cmp    $0x4,%r14d
sete   %al
cmp    $0x3,%r15d
sete   %cl
cmp    $0x5,%r15d
sete   %dl
or     %cl,%dl
or     %al,%dl
movzbl %dl,%edi
call   1050 <assert@plt>
movapd 0xb0(%rsp),%xmm0
ucomisd 0xd0d(%rip),%xmm0
jb     134b <LookBarrier+0x1bb>
sqrtsd %xmm0,%xmm0
jmp    1350 <LookBarrier+0x1c0>
call   10b0 <sqrt@plt>
mulsd  0x38(%rsp),%xmm0
xor    %edi,%edi
movapd %xmm0,0x40(%rsp)
ucomisd %xmm0,%xmm0
setnp  %dil
call   1050 <assert@plt>
movsd  0x38(%rsp),%xmm0
mulsd  %xmm0,%xmm0
movsd  %xmm0,0x18(%rsp)
movapd 0xcdd(%rip),%xmm0
xorpd  0x170(%rsp),%xmm0
mulsd  0x90(%rsp),%xmm0
call   1070 <exp@plt>
movapd %xmm0,0xf0(%rsp)
movapd 0x90(%rsp),%xmm0
ucomisd 0xc9c(%rip),%xmm0
jb     13c8 <LookBarrier+0x238>
xorps  %xmm1,%xmm1
sqrtsd %xmm0,%xmm1
movapd %xmm1,0x80(%rsp)
jmp    13d6 <LookBarrier+0x246>
call   10b0 <sqrt@plt>
movapd %xmm0,0x80(%rsp)
movsd  0x108(%rsp),%xmm0
divsd  0x30(%rsp),%xmm0
call   1080 <log@plt>
movapd %xmm0,(%rsp)
movapd 0x150(%rsp),%xmm0
divsd  0x30(%rsp),%xmm0
call   1080 <log@plt>
movapd %xmm0,0x140(%rsp)
movsd  0xc1c(%rip),%xmm0
mulsd  0x18(%rsp),%xmm0
movsd  %xmm0,0x70(%rsp)
addsd  0xe0(%rsp),%xmm0
xor    %edi,%edi
movapd %xmm0,0xd0(%rsp)
ucomisd %xmm0,%xmm0
setnp  %dil
call   1050 <assert@plt>
movapd 0xb0(%rsp),%xmm0
divsd  0x90(%rsp),%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1463 <LookBarrier+0x2d3>
sqrtsd %xmm0,%xmm0
jmp    1468 <LookBarrier+0x2d8>
call   10b0 <sqrt@plt>
lea    -0x3(%r15),%eax
cmp    $0x1,%eax
movapd 0x140(%rsp),%xmm1
movapd (%rsp),%xmm3
movapd %xmm0,0x1d0(%rsp)
ja     14b8 <LookBarrier+0x328>
movapd %xmm3,%xmm2
cmpunordsd %xmm3,%xmm2
movapd %xmm2,%xmm0
andpd  %xmm1,%xmm0
minsd  %xmm3,%xmm1
andnpd %xmm1,%xmm2
orpd   %xmm0,%xmm2
movapd %xmm2,0x130(%rsp)
movsd  0xb8a(%rip),%xmm0
jmp    14f3 <LookBarrier+0x363>
lea    -0x5(%r15),%eax
cmp    $0x1,%eax
ja     1e46 <LookBarrier+0xcb6>
movapd %xmm3,%xmm2
cmpunordsd %xmm3,%xmm2
movapd %xmm2,%xmm0
andpd  %xmm1,%xmm0
maxsd  %xmm3,%xmm1
andnpd %xmm1,%xmm2
orpd   %xmm0,%xmm2
movapd %xmm2,0x130(%rsp)
movsd  0xb45(%rip),%xmm0
movaps %xmm0,0x20(%rsp)
movapd 0x80(%rsp),%xmm0
mulsd  0x38(%rsp),%xmm0
movapd %xmm0,0x80(%rsp)
movapd 0xe0(%rsp),%xmm0
subsd  0x70(%rsp),%xmm0
movapd %xmm0,0x70(%rsp)
movapd 0xd0(%rsp),%xmm0
addsd  %xmm0,%xmm0
mulsd  %xmm3,%xmm0
divsd  0x18(%rsp),%xmm0
call   1070 <exp@plt>
movapd %xmm0,0xa0(%rsp)
movapd 0x70(%rsp),%xmm0
addsd  %xmm0,%xmm0
mulsd  (%rsp),%xmm0
divsd  0x18(%rsp),%xmm0
call   1070 <exp@plt>
movapd %xmm0,0xc0(%rsp)
movapd 0xd0(%rsp),%xmm0
xorpd  0xae2(%rip),%xmm0
movapd %xmm0,0x50(%rsp)
mulsd  0xb0(%rsp),%xmm0
movapd %xmm0,0x120(%rsp)
addsd  (%rsp),%xmm0
mulsd  0x20(%rsp),%xmm0
divsd  0x40(%rsp),%xmm0
call   1090 <cnd@plt>
movsd  %xmm0,0x68(%rsp)
movapd 0x120(%rsp),%xmm0
subsd  (%rsp),%xmm0
mulsd  0x20(%rsp),%xmm0
divsd  0x40(%rsp),%xmm0
call   1090 <cnd@plt>
movapd 0xa0(%rsp),%xmm2
movapd %xmm2,%xmm1
unpcklpd 0xc0(%rsp),%xmm1
movapd %xmm1,0x1c0(%rsp)
movapd 0xa68(%rip),%xmm1
xorpd  %xmm1,%xmm2
movapd %xmm2,0xa0(%rsp)
mulsd  %xmm2,%xmm0
addsd  0x68(%rsp),%xmm0
movsd  %xmm0,0x68(%rsp)
movapd 0x140(%rsp),%xmm0
xorpd  %xmm1,%xmm0
movapd (%rsp),%xmm1
unpcklpd %xmm1,%xmm1
unpcklpd 0x130(%rsp),%xmm0
mulpd  0xa34(%rip),%xmm1
addpd  %xmm0,%xmm1
movapd %xmm1,%xmm2
movapd %xmm1,0x1e0(%rsp)
movapd 0xd0(%rsp),%xmm1
unpcklpd 0x50(%rsp),%xmm1
movapd 0x90(%rsp),%xmm3
unpcklpd 0xb0(%rsp),%xmm3
mulpd  %xmm1,%xmm3
movapd %xmm3,%xmm1
addpd  %xmm2,%xmm1
addpd  %xmm0,%xmm3
movapd 0x20(%rsp),%xmm2
unpcklpd %xmm2,%xmm2
mulpd  %xmm2,%xmm3
mulpd  %xmm1,%xmm2
movapd 0x80(%rsp),%xmm0
unpcklpd 0x40(%rsp),%xmm0
divpd  %xmm0,%xmm2
movapd %xmm2,0x110(%rsp)
divpd  %xmm0,%xmm3
movapd %xmm3,0x160(%rsp)
movapd %xmm3,%xmm0
unpckhpd %xmm3,%xmm0
movapd %xmm0,0x180(%rsp)
call   1090 <cnd@plt>
movsd  %xmm0,0x50(%rsp)
movapd 0x110(%rsp),%xmm0
unpckhpd %xmm0,%xmm0
movapd %xmm0,0x190(%rsp)
call   1090 <cnd@plt>
mulsd  0xa0(%rsp),%xmm0
addsd  0x50(%rsp),%xmm0
movsd  %xmm0,0x1f8(%rsp)
movapd 0x70(%rsp),%xmm0
xorpd  0x94a(%rip),%xmm0
movapd %xmm0,0x120(%rsp)
mulsd  0xb0(%rsp),%xmm0
movapd %xmm0,0x50(%rsp)
addsd  (%rsp),%xmm0
mulsd  0x20(%rsp),%xmm0
divsd  0x40(%rsp),%xmm0
call   1090 <cnd@plt>
movapd %xmm0,0xa0(%rsp)
movapd 0x50(%rsp),%xmm0
subsd  (%rsp),%xmm0
mulsd  0x20(%rsp),%xmm0
divsd  0x40(%rsp),%xmm0
call   1090 <cnd@plt>
movapd %xmm0,(%rsp)
movapd 0x50(%rsp),%xmm0
addsd  0x130(%rsp),%xmm0
mulsd  0x20(%rsp),%xmm0
divsd  0x40(%rsp),%xmm0
movapd %xmm0,0x1a0(%rsp)
call   1090 <cnd@plt>
movapd %xmm0,0x1b0(%rsp)
movapd 0x1e0(%rsp),%xmm1
unpckhpd %xmm1,%xmm1
movapd %xmm1,0x220(%rsp)
movapd 0x50(%rsp),%xmm0
addsd  %xmm1,%xmm0
mulsd  0x20(%rsp),%xmm0
divsd  0x40(%rsp),%xmm0
movapd %xmm0,0x50(%rsp)
call   1090 <cnd@plt>
movapd 0xc0(%rsp),%xmm1
unpcklpd %xmm1,%xmm1
movapd (%rsp),%xmm2
unpcklpd %xmm0,%xmm2
mulpd  %xmm1,%xmm2
movapd 0xa0(%rsp),%xmm0
unpcklpd 0x1b0(%rsp),%xmm0
subpd  %xmm2,%xmm0
movapd %xmm0,0xa0(%rsp)
unpckhpd %xmm0,%xmm0
movapd %xmm0,0x1b0(%rsp)
xorpd  %xmm0,%xmm0
movapd 0x160(%rsp),%xmm1
cmpordpd %xmm0,%xmm1
cmpordpd 0x110(%rsp),%xmm0
packssdw %xmm1,%xmm0
movmskps %xmm0,%ebp
mov    %ebp,%r12d
and    $0x2,%r12b
shr    %r12b
mov    %ebp,%ebx
and    $0x4,%bl
shr    $0x2,%bl
mov    %ebp,%eax
shr    $0x3,%al
movzbl %al,%edi
call   1050 <assert@plt>
movzbl %bl,%edi
call   1050 <assert@plt>
movapd 0x1d0(%rsp),%xmm0
movapd %xmm0,%xmm1
xorpd  0x7e4(%rip),%xmm1
movapd %xmm1,(%rsp)
xor    %edi,%edi
ucomisd %xmm0,%xmm0
setnp  %dil
call   1050 <assert@plt>
movaps 0x180(%rsp),%xmm0
movaps 0x160(%rsp),%xmm1
movaps (%rsp),%xmm2
call   1040 <cbnd@plt>
movaps %xmm0,0xc0(%rsp)
movzbl %r12b,%edi
call   1050 <assert@plt>
and    $0x1,%ebp
mov    %ebp,%edi
call   1050 <assert@plt>
movapd 0x190(%rsp),%xmm0
movaps 0x110(%rsp),%xmm1
movaps (%rsp),%xmm2
call   1040 <cbnd@plt>
movapd %xmm0,0x180(%rsp)
xor    %edi,%edi
ucomisd %xmm0,%xmm0
setnp  %dil
call   1050 <assert@plt>
movapd 0xe0(%rsp),%xmm0
subsd  0x170(%rsp),%xmm0
mulsd  0x90(%rsp),%xmm0
movapd %xmm0,0x190(%rsp)
call   1070 <exp@plt>
mulsd  0x30(%rsp),%xmm0
movapd 0xe0(%rsp),%xmm1
addsd  %xmm1,%xmm1
movapd %xmm1,0x210(%rsp)
movsd  0x18(%rsp),%xmm2
divsd  %xmm1,%xmm2
movsd  0x6f3(%rip),%xmm1
movsd  %xmm2,0x1d0(%rsp)
addsd  %xmm2,%xmm1
movapd 0xf0(%rsp),%xmm2
xorpd  0x6f5(%rip),%xmm2
movapd %xmm2,0xf0(%rsp)
movapd %xmm1,0x160(%rsp)
unpcklpd %xmm2,%xmm1
unpcklpd 0x150(%rsp),%xmm0
mulpd  %xmm1,%xmm0
movapd %xmm0,0x110(%rsp)
movapd 0x70(%rsp),%xmm1
mulsd  0x90(%rsp),%xmm1
movapd %xmm1,0x200(%rsp)
subsd  0x140(%rsp),%xmm1
mulsd  0x20(%rsp),%xmm1
divsd  0x80(%rsp),%xmm1
movaps 0x1a0(%rsp),%xmm0
movaps (%rsp),%xmm2
call   1040 <cbnd@plt>
movaps %xmm0,0x1a0(%rsp)
movapd 0x200(%rsp),%xmm1
addsd  0x1e0(%rsp),%xmm1
mulsd  0x20(%rsp),%xmm1
divsd  0x80(%rsp),%xmm1
movapd 0x50(%rsp),%xmm0
movaps (%rsp),%xmm2
call   1040 <cbnd@plt>
movapd 0x180(%rsp),%xmm1
unpcklpd %xmm0,%xmm1
mulpd  0x1c0(%rsp),%xmm1
movapd 0xc0(%rsp),%xmm0
unpcklpd 0x1a0(%rsp),%xmm0
subpd  %xmm1,%xmm0
movapd %xmm0,0xc0(%rsp)
movsd  0x18(%rsp),%xmm2
movapd 0xf0(%rsp),%xmm0
mulsd  %xmm2,%xmm0
divsd  0x210(%rsp),%xmm0
movapd %xmm0,0xf0(%rsp)
movsd  0x30(%rsp),%xmm0
divsd  0x150(%rsp),%xmm0
movsd  0x5c7(%rip),%xmm1
mulsd  0xe0(%rsp),%xmm1
divsd  %xmm2,%xmm1
movsd  %xmm1,0x1c0(%rsp)
call   10a0 <pow@plt>
mulsd  0x30(%rsp),%xmm0
movsd  %xmm0,0x50(%rsp)
movapd 0x70(%rsp),%xmm0
mulsd  0xb0(%rsp),%xmm0
movapd %xmm0,0x70(%rsp)
movapd 0x130(%rsp),%xmm1
addsd  %xmm0,%xmm1
movapd 0x20(%rsp),%xmm2
mulsd  %xmm2,%xmm1
divsd  0x40(%rsp),%xmm1
movapd %xmm1,%xmm0
movapd 0x120(%rsp),%xmm1
mulsd  0x90(%rsp),%xmm1
movapd %xmm1,0x130(%rsp)
subsd  0x140(%rsp),%xmm1
mulsd  %xmm2,%xmm1
divsd  0x80(%rsp),%xmm1
movaps (%rsp),%xmm2
call   1040 <cbnd@plt>
movsd  %xmm0,0x18(%rsp)
movsd  0x108(%rsp),%xmm0
divsd  0x150(%rsp),%xmm0
movsd  0x1c0(%rsp),%xmm1
call   10a0 <pow@plt>
movsd  %xmm0,0x140(%rsp)
movapd 0x70(%rsp),%xmm0
addsd  0x220(%rsp),%xmm0
movapd 0x20(%rsp),%xmm1
mulsd  %xmm1,%xmm0
divsd  0x40(%rsp),%xmm0
movapd 0x130(%rsp),%xmm2
addsd  0x1e0(%rsp),%xmm2
mulsd  %xmm1,%xmm2
divsd  0x80(%rsp),%xmm2
movapd %xmm2,%xmm1
movaps (%rsp),%xmm2
call   1040 <cbnd@plt>
movsd  0x140(%rsp),%xmm1
mulsd  0x108(%rsp),%xmm1
mulsd  %xmm0,%xmm1
movsd  0x18(%rsp),%xmm0
mulsd  0x50(%rsp),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,0x18(%rsp)
movapd 0x190(%rsp),%xmm0
call   1070 <exp@plt>
movapd %xmm0,%xmm2
movapd 0xd0(%rsp),%xmm0
mulsd  0x20(%rsp),%xmm0
movapd 0x90(%rsp),%xmm1
subsd  0xb0(%rsp),%xmm1
mulsd  %xmm1,%xmm0
movapd %xmm0,0xd0(%rsp)
xorps  %xmm0,%xmm0
sqrtsd %xmm1,%xmm0
xorpd  %xmm3,%xmm3
movapd %xmm1,0x40(%rsp)
ucomisd %xmm3,%xmm1
movsd  %xmm0,0x80(%rsp)
jae    1c33 <LookBarrier+0xaa3>
movapd 0x40(%rsp),%xmm0
movsd  %xmm2,(%rsp)
call   10b0 <sqrt@plt>
movsd  (%rsp),%xmm2
movsd  0x68(%rsp),%xmm1
subsd  0x1f8(%rsp),%xmm1
movsd  %xmm1,0x68(%rsp)
movapd 0xa0(%rsp),%xmm1
subpd  0x1b0(%rsp),%xmm1
movapd %xmm1,0xa0(%rsp)
movapd 0xc0(%rsp),%xmm1
mulpd  0x110(%rsp),%xmm1
movapd %xmm1,0xc0(%rsp)
movapd 0xf0(%rsp),%xmm1
mulsd  0x18(%rsp),%xmm1
movapd %xmm1,0xf0(%rsp)
mulsd  0x30(%rsp),%xmm2
movsd  %xmm2,(%rsp)
mulsd  0x38(%rsp),%xmm0
movapd 0xd0(%rsp),%xmm1
divsd  %xmm0,%xmm1
movapd %xmm1,%xmm0
call   1090 <cnd@plt>
movsd  %xmm0,0xd0(%rsp)
movapd 0x392(%rip),%xmm0
xorpd  0xe0(%rsp),%xmm0
mulsd  0x40(%rsp),%xmm0
call   1070 <exp@plt>
movsd  0x356(%rip),%xmm1
subsd  0x1d0(%rsp),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x70(%rsp)
movapd 0x120(%rsp),%xmm0
movapd 0x40(%rsp),%xmm1
mulsd  %xmm1,%xmm0
mulsd  0x20(%rsp),%xmm0
ucomisd 0x332(%rip),%xmm1
movsd  0x80(%rsp),%xmm1
jae    1d4a <LookBarrier+0xbba>
movapd %xmm0,0x120(%rsp)
movapd 0x40(%rsp),%xmm0
call   10b0 <sqrt@plt>
movapd %xmm0,%xmm1
movapd 0x120(%rsp),%xmm0
mulsd  0x38(%rsp),%xmm1
divsd  %xmm1,%xmm0
call   1090 <cnd@plt>
movsd  0x70(%rsp),%xmm1
mulsd  %xmm0,%xmm1
movapd 0x160(%rsp),%xmm0
mulsd  0xd0(%rsp),%xmm0
addsd  %xmm1,%xmm0
movsd  (%rsp),%xmm1
mulsd  %xmm0,%xmm1
mulsd  0x68(%rsp),%xmm1
movapd 0x110(%rsp),%xmm2
unpckhpd %xmm2,%xmm2
mulsd  0xa0(%rsp),%xmm2
addsd  %xmm1,%xmm2
movapd 0xc0(%rsp),%xmm1
movapd %xmm1,%xmm0
unpckhpd %xmm1,%xmm0
addsd  %xmm1,%xmm0
addsd  0xf0(%rsp),%xmm0
addsd  %xmm2,%xmm0
movapd 0x20(%rsp),%xmm1
mulsd  %xmm0,%xmm1
movapd %xmm1,%xmm0
cmp    $0x4,%r14d
je     1e36 <LookBarrier+0xca6>
movapd %xmm0,0x20(%rsp)
cmp    $0x3,%r15d
je     1dea <LookBarrier+0xc5a>
cmp    $0x5,%r15d
jne    1e46 <LookBarrier+0xcb6>
xor    %edi,%edi
cmp    $0x3,%r15d
sete   %dil
movsd  0x30(%rsp),%xmm0
movapd 0x150(%rsp),%xmm1
movapd 0xb0(%rsp),%xmm2
movapd 0x90(%rsp),%xmm3
movaps 0x170(%rsp),%xmm4
movaps 0xe0(%rsp),%xmm5
movsd  0x38(%rsp),%xmm6
call   1060 <PartialFixedLB@plt>
subsd  0x20(%rsp),%xmm0
add    $0x230,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %eax,%eax
call   1030 <abort@plt>

LLVM IR (-O0):
define double @LookBarrier(i32 %0, double %1, double %2, double %3, double %4, double %5, double %6, double %7, double %8) {
%10 = alloca i32
%11 = alloca double
%12 = alloca double
%13 = alloca double
%14 = alloca double
%15 = alloca double
%16 = alloca double
%17 = alloca double
%18 = alloca double
%19 = alloca double
%20 = alloca double
%21 = alloca double
%22 = alloca double
%23 = alloca double
%24 = alloca double
%25 = alloca double
%26 = alloca double
%27 = alloca double
%28 = alloca double
%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
%39 = alloca double
%40 = alloca double
%41 = alloca double
%42 = alloca double
%43 = alloca double
%44 = alloca double
store i32 %0, i32* %10
store double %1, double* %11
store double %2, double* %12
store double %3, double* %13
store double %4, double* %14
store double %5, double* %15
store double %6, double* %16
store double %7, double* %17
store double %8, double* %18
%45 = load double, double* %11
%46 = load double, double* %11
%47 = fcmp oeq double %45, %46
br i1 %47, label %48, label %54
48: ; preds = %9
%49 = load double, double* %11
%50 = fcmp oge double %49, 0x3EB0C6F7A0B5ED8D
br i1 %50, label %51, label %54
51: ; preds = %48
%52 = load double, double* %11
%53 = fcmp ole double %52, 1.000000e+12
br label %54
54: ; preds = %51, %48, %9
%55 = phi i1 [ false, %48 ], [ false, %9 ], [ %53, %51 ]
%56 = zext i1 %55 to i32
%57 = call i32 @assert(i32 %56)
%58 = load double, double* %12
%59 = load double, double* %12
%60 = fcmp oeq double %58, %59
br i1 %60, label %61, label %67
61: ; preds = %54
%62 = load double, double* %12
%63 = fcmp oge double %62, 0x3EB0C6F7A0B5ED8D
br i1 %63, label %64, label %67
64: ; preds = %61
%65 = load double, double* %12
%66 = fcmp ole double %65, 1.000000e+12
br label %67
67: ; preds = %64, %61, %54
%68 = phi i1 [ false, %61 ], [ false, %54 ], [ %66, %64 ]
%69 = zext i1 %68 to i32
%70 = call i32 @assert(i32 %69)
%71 = load double, double* %16
%72 = load double, double* %16
%73 = fcmp oeq double %71, %72
br i1 %73, label %74, label %80
74: ; preds = %67
%75 = load double, double* %16
%76 = fcmp oge double %75, 0.000000e+00
br i1 %76, label %77, label %80
77: ; preds = %74
%78 = load double, double* %16
%79 = fcmp ole double %78, 1.000000e+03
br label %80
80: ; preds = %77, %74, %67
%81 = phi i1 [ false, %74 ], [ false, %67 ], [ %79, %77 ]
%82 = zext i1 %81 to i32
%83 = call i32 @assert(i32 %82)
%84 = load double, double* %17
%85 = load double, double* %17
%86 = fcmp oeq double %84, %85
br i1 %86, label %87, label %93
87: ; preds = %80
%88 = load double, double* %17
%89 = fcmp oge double %88, -1.000000e+03
br i1 %89, label %90, label %93
90: ; preds = %87
%91 = load double, double* %17
%92 = fcmp ole double %91, 1.000000e+03
br label %93
93: ; preds = %90, %87, %80
%94 = phi i1 [ false, %87 ], [ false, %80 ], [ %92, %90 ]
%95 = zext i1 %94 to i32
%96 = call i32 @assert(i32 %95)
%97 = load double, double* %18
%98 = load double, double* %18
%99 = fcmp oeq double %97, %98
br i1 %99, label %100, label %106
100: ; preds = %93
%101 = load double, double* %18
%102 = fcmp oge double %101, 0x3E7AD7F29ABCAF48
br i1 %102, label %103, label %106
103: ; preds = %100
%104 = load double, double* %18
%105 = fcmp ole double %104, 0x40593FFFD60E94EE
br label %106
106: ; preds = %103, %100, %93
%107 = phi i1 [ false, %100 ], [ false, %93 ], [ %105, %103 ]
%108 = zext i1 %107 to i32
%109 = call i32 @assert(i32 %108)
%110 = load double, double* %14
%111 = load double, double* %14
%112 = fcmp oeq double %110, %111
%113 = zext i1 %112 to i32
%114 = call i32 @assert(i32 %113)
%115 = load double, double* %15
%116 = load double, double* %15
%117 = fcmp oeq double %115, %116
%118 = zext i1 %117 to i32
%119 = call i32 @assert(i32 %118)
%120 = load i32, i32* %10
%121 = icmp eq i32 %120, 4
br i1 %121, label %131, label %122
122: ; preds = %106
%123 = load i32, i32* %10
%124 = icmp eq i32 %123, 6
br i1 %124, label %131, label %125
125: ; preds = %122
%126 = load i32, i32* %10
%127 = icmp eq i32 %126, 3
br i1 %127, label %131, label %128
128: ; preds = %125
%129 = load i32, i32* %10
%130 = icmp eq i32 %129, 5
br label %131
131: ; preds = %128, %125, %122, %106
%132 = phi i1 [ true, %125 ], [ true, %122 ], [ true, %106 ], [ %130, %128 ]
%133 = zext i1 %132 to i32
%134 = call i32 @assert(i32 %133)
%135 = load double, double* %18
%136 = load double, double* %14
%137 = call double @sqrt(double %136)
%138 = fmul double %135, %137
store double %138, double* %19
%139 = load double, double* %19
%140 = load double, double* %19
%141 = fcmp oeq double %139, %140
%142 = zext i1 %141 to i32
%143 = call i32 @assert(i32 %142)
%144 = load double, double* %18
%145 = load double, double* %18
%146 = fmul double %144, %145
store double %146, double* %20
%147 = load double, double* %16
%148 = fneg double %147
%149 = load double, double* %15
%150 = fmul double %148, %149
%151 = call double @exp(double %150)
store double %151, double* %21
%152 = load double, double* %18
%153 = load double, double* %15
%154 = call double @sqrt(double %153)
%155 = fmul double %152, %154
store double %155, double* %22
%156 = load double, double* %13
%157 = load double, double* %11
%158 = fdiv double %156, %157
%159 = call double @log(double %158)
store double %159, double* %23
%160 = load double, double* %12
%161 = load double, double* %11
%162 = fdiv double %160, %161
%163 = call double @log(double %162)
store double %163, double* %24
%164 = load double, double* %17
%165 = load double, double* %20
%166 = fdiv double %165, 2.000000e+00
%167 = fsub double %164, %166
store double %167, double* %25
%168 = load double, double* %17
%169 = load double, double* %20
%170 = fdiv double %169, 2.000000e+00
%171 = fadd double %168, %170
store double %171, double* %26
%172 = load double, double* %26
%173 = load double, double* %26
%174 = fcmp oeq double %172, %173
%175 = zext i1 %174 to i32
%176 = call i32 @assert(i32 %175)
%177 = load double, double* %14
%178 = load double, double* %15
%179 = fdiv double %177, %178
%180 = call double @sqrt(double %179)
store double %180, double* %27
%181 = load i32, i32* %10
%182 = icmp eq i32 %181, 4
br i1 %182, label %186, label %183
183: ; preds = %131
%184 = load i32, i32* %10
%185 = icmp eq i32 %184, 3
br i1 %185, label %186, label %190
186: ; preds = %183, %131
store double 1.000000e+00, double* %28
%187 = load double, double* %23
%188 = load double, double* %24
%189 = call double @llvm.minnum.f64(double %187, double %188)
store double %189, double* %29
br label %203
190: ; preds = %183
%191 = load i32, i32* %10
%192 = icmp eq i32 %191, 6
br i1 %192, label %196, label %193
193: ; preds = %190
%194 = load i32, i32* %10
%195 = icmp eq i32 %194, 5
br i1 %195, label %196, label %200
196: ; preds = %193, %190
store double -1.000000e+00, double* %28
%197 = load double, double* %23
%198 = load double, double* %24
%199 = call double @llvm.maxnum.f64(double %197, double %198)
store double %199, double* %29
br label %202
200: ; preds = %193
%201 = call i32 (...) @abort()
unreachable
202: ; preds = %196
br label %203
203: ; preds = %202, %186
%204 = load double, double* %26
%205 = fmul double 2.000000e+00, %204
%206 = load double, double* %23
%207 = fmul double %205, %206
%208 = load double, double* %20
%209 = fdiv double %207, %208
%210 = call double @exp(double %209)
store double %210, double* %30
%211 = load double, double* %25
%212 = fmul double 2.000000e+00, %211
%213 = load double, double* %23
%214 = fmul double %212, %213
%215 = load double, double* %20
%216 = fdiv double %214, %215
%217 = call double @exp(double %216)
store double %217, double* %31
%218 = load double, double* %28
%219 = load double, double* %23
%220 = load double, double* %26
%221 = load double, double* %14
%222 = fneg double %220
%223 = call double @llvm.fmuladd.f64(double %222, double %221, double %219)
%224 = fmul double %218, %223
%225 = load double, double* %19
%226 = fdiv double %224, %225
%227 = call double @cnd(double %226)
%228 = load double, double* %30
%229 = load double, double* %28
%230 = load double, double* %23
%231 = fneg double %230
%232 = load double, double* %26
%233 = load double, double* %14
%234 = fneg double %232
%235 = call double @llvm.fmuladd.f64(double %234, double %233, double %231)
%236 = fmul double %229, %235
%237 = load double, double* %19
%238 = fdiv double %236, %237
%239 = call double @cnd(double %238)
%240 = fneg double %228
%241 = call double @llvm.fmuladd.f64(double %240, double %239, double %227)
%242 = load double, double* %28
%243 = load double, double* %29
%244 = load double, double* %26
%245 = load double, double* %14
%246 = fneg double %244
%247 = call double @llvm.fmuladd.f64(double %246, double %245, double %243)
%248 = fmul double %242, %247
%249 = load double, double* %19
%250 = fdiv double %248, %249
%251 = call double @cnd(double %250)
%252 = load double, double* %30
%253 = load double, double* %28
%254 = load double, double* %29
%255 = load double, double* %23
%256 = call double @llvm.fmuladd.f64(double -2.000000e+00, double %255, double %254)
%257 = load double, double* %26
%258 = load double, double* %14
%259 = fneg double %257
%260 = call double @llvm.fmuladd.f64(double %259, double %258, double %256)
%261 = fmul double %253, %260
%262 = load double, double* %19
%263 = fdiv double %261, %262
%264 = call double @cnd(double %263)
%265 = fneg double %252
%266 = call double @llvm.fmuladd.f64(double %265, double %264, double %251)
%267 = fsub double %241, %266
store double %267, double* %32
%268 = load double, double* %28
%269 = load double, double* %23
%270 = load double, double* %25
%271 = load double, double* %14
%272 = fneg double %270
%273 = call double @llvm.fmuladd.f64(double %272, double %271, double %269)
%274 = fmul double %268, %273
%275 = load double, double* %19
%276 = fdiv double %274, %275
%277 = call double @cnd(double %276)
%278 = load double, double* %31
%279 = load double, double* %28
%280 = load double, double* %23
%281 = fneg double %280
%282 = load double, double* %25
%283 = load double, double* %14
%284 = fneg double %282
%285 = call double @llvm.fmuladd.f64(double %284, double %283, double %281)
%286 = fmul double %279, %285
%287 = load double, double* %19
%288 = fdiv double %286, %287
%289 = call double @cnd(double %288)
%290 = fneg double %278
%291 = call double @llvm.fmuladd.f64(double %290, double %289, double %277)
%292 = load double, double* %28
%293 = load double, double* %29
%294 = load double, double* %25
%295 = load double, double* %14
%296 = fneg double %294
%297 = call double @llvm.fmuladd.f64(double %296, double %295, double %293)
%298 = fmul double %292, %297
%299 = load double, double* %19
%300 = fdiv double %298, %299
%301 = call double @cnd(double %300)
%302 = load double, double* %31
%303 = load double, double* %28
%304 = load double, double* %29
%305 = load double, double* %23
%306 = call double @llvm.fmuladd.f64(double -2.000000e+00, double %305, double %304)
%307 = load double, double* %25
%308 = load double, double* %14
%309 = fneg double %307
%310 = call double @llvm.fmuladd.f64(double %309, double %308, double %306)
%311 = fmul double %303, %310
%312 = load double, double* %19
%313 = fdiv double %311, %312
%314 = call double @cnd(double %313)
%315 = fneg double %302
%316 = call double @llvm.fmuladd.f64(double %315, double %314, double %301)
%317 = fsub double %291, %316
store double %317, double* %33
%318 = load double, double* %28
%319 = load double, double* %29
%320 = load double, double* %26
%321 = load double, double* %14
%322 = fneg double %320
%323 = call double @llvm.fmuladd.f64(double %322, double %321, double %319)
%324 = fmul double %318, %323
%325 = load double, double* %19
%326 = fdiv double %324, %325
store double %326, double* %34
%327 = load double, double* %34
%328 = load double, double* %34
%329 = fcmp oeq double %327, %328
%330 = zext i1 %329 to i32
%331 = call i32 @assert(i32 %330)
%332 = load double, double* %28
%333 = load double, double* %24
%334 = fneg double %333
%335 = load double, double* %26
%336 = load double, double* %15
%337 = call double @llvm.fmuladd.f64(double %335, double %336, double %334)
%338 = fmul double %332, %337
%339 = load double, double* %22
%340 = fdiv double %338, %339
store double %340, double* %35
%341 = load double, double* %35
%342 = load double, double* %35
%343 = fcmp oeq double %341, %342
%344 = zext i1 %343 to i32
%345 = call i32 @assert(i32 %344)
%346 = load double, double* %27
%347 = fneg double %346
store double %347, double* %36
%348 = load double, double* %36
%349 = load double, double* %36
%350 = fcmp oeq double %348, %349
%351 = zext i1 %350 to i32
%352 = call i32 @assert(i32 %351)
%353 = load double, double* %34
%354 = load double, double* %35
%355 = load double, double* %36
%356 = call double @cbnd(double %353, double %354, double %355)
store double %356, double* %37
%357 = load double, double* %28
%358 = load double, double* %29
%359 = load double, double* %23
%360 = call double @llvm.fmuladd.f64(double -2.000000e+00, double %359, double %358)
%361 = load double, double* %26
%362 = load double, double* %14
%363 = fneg double %361
%364 = call double @llvm.fmuladd.f64(double %363, double %362, double %360)
%365 = fmul double %357, %364
%366 = load double, double* %19
%367 = fdiv double %365, %366
store double %367, double* %34
%368 = load double, double* %34
%369 = load double, double* %34
%370 = fcmp oeq double %368, %369
%371 = zext i1 %370 to i32
%372 = call i32 @assert(i32 %371)
%373 = load double, double* %28
%374 = load double, double* %23
%375 = load double, double* %24
%376 = fneg double %375
%377 = call double @llvm.fmuladd.f64(double 2.000000e+00, double %374, double %376)
%378 = load double, double* %26
%379 = load double, double* %15
%380 = call double @llvm.fmuladd.f64(double %378, double %379, double %377)
%381 = fmul double %373, %380
%382 = load double, double* %22
%383 = fdiv double %381, %382
store double %383, double* %35
%384 = load double, double* %35
%385 = load double, double* %35
%386 = fcmp oeq double %384, %385
%387 = zext i1 %386 to i32
%388 = call i32 @assert(i32 %387)
%389 = load double, double* %34
%390 = load double, double* %35
%391 = load double, double* %36
%392 = call double @cbnd(double %389, double %390, double %391)
store double %392, double* %38
%393 = load double, double* %38
%394 = load double, double* %38
%395 = fcmp oeq double %393, %394
%396 = zext i1 %395 to i32
%397 = call i32 @assert(i32 %396)
%398 = load double, double* %11
%399 = load double, double* %17
%400 = load double, double* %16
%401 = fsub double %399, %400
%402 = load double, double* %15
%403 = fmul double %401, %402
%404 = call double @exp(double %403)
%405 = fmul double %398, %404
%406 = load double, double* %20
%407 = load double, double* %17
%408 = fmul double 2.000000e+00, %407
%409 = fdiv double %406, %408
%410 = fadd double 1.000000e+00, %409
%411 = fmul double %405, %410
%412 = load double, double* %37
%413 = load double, double* %30
%414 = load double, double* %38
%415 = fneg double %413
%416 = call double @llvm.fmuladd.f64(double %415, double %414, double %412)
%417 = fmul double %411, %416
store double %417, double* %39
%418 = load double, double* %21
%419 = fneg double %418
%420 = load double, double* %12
%421 = fmul double %419, %420
%422 = load double, double* %28
%423 = load double, double* %29
%424 = load double, double* %25
%425 = load double, double* %14
%426 = fneg double %424
%427 = call double @llvm.fmuladd.f64(double %426, double %425, double %423)
%428 = fmul double %422, %427
%429 = load double, double* %19
%430 = fdiv double %428, %429
%431 = load double, double* %28
%432 = load double, double* %24
%433 = fneg double %432
%434 = load double, double* %25
%435 = load double, double* %15
%436 = call double @llvm.fmuladd.f64(double %434, double %435, double %433)
%437 = fmul double %431, %436
%438 = load double, double* %22
%439 = fdiv double %437, %438
%440 = load double, double* %27
%441 = fneg double %440
%442 = call double @cbnd(double %430, double %439, double %441)
%443 = load double, double* %31
%444 = load double, double* %28
%445 = load double, double* %29
%446 = load double, double* %23
%447 = call double @llvm.fmuladd.f64(double -2.000000e+00, double %446, double %445)
%448 = load double, double* %25
%449 = load double, double* %14
%450 = fneg double %448
%451 = call double @llvm.fmuladd.f64(double %450, double %449, double %447)
%452 = fmul double %444, %451
%453 = load double, double* %19
%454 = fdiv double %452, %453
%455 = load double, double* %28
%456 = load double, double* %23
%457 = load double, double* %24
%458 = fneg double %457
%459 = call double @llvm.fmuladd.f64(double 2.000000e+00, double %456, double %458)
%460 = load double, double* %25
%461 = load double, double* %15
%462 = call double @llvm.fmuladd.f64(double %460, double %461, double %459)
%463 = fmul double %455, %462
%464 = load double, double* %22
%465 = fdiv double %463, %464
%466 = load double, double* %27
%467 = fneg double %466
%468 = call double @cbnd(double %454, double %465, double %467)
%469 = fneg double %443
%470 = call double @llvm.fmuladd.f64(double %469, double %468, double %442)
%471 = fmul double %421, %470
store double %471, double* %40
%472 = load double, double* %21
%473 = fneg double %472
%474 = load double, double* %20
%475 = fmul double %473, %474
%476 = load double, double* %17
%477 = fmul double 2.000000e+00, %476
%478 = fdiv double %475, %477
%479 = load double, double* %11
%480 = load double, double* %11
%481 = load double, double* %12
%482 = fdiv double %480, %481
%483 = load double, double* %17
%484 = fmul double -2.000000e+00, %483
%485 = load double, double* %20
%486 = fdiv double %484, %485
%487 = call double @pow(double %482, double %486)
%488 = fmul double %479, %487
%489 = load double, double* %28
%490 = load double, double* %29
%491 = load double, double* %25
%492 = load double, double* %14
%493 = call double @llvm.fmuladd.f64(double %491, double %492, double %490)
%494 = fmul double %489, %493
%495 = load double, double* %19
%496 = fdiv double %494, %495
%497 = load double, double* %28
%498 = load double, double* %24
%499 = fneg double %498
%500 = load double, double* %25
%501 = load double, double* %15
%502 = fneg double %500
%503 = call double @llvm.fmuladd.f64(double %502, double %501, double %499)
%504 = fmul double %497, %503
%505 = load double, double* %22
%506 = fdiv double %504, %505
%507 = load double, double* %27
%508 = fneg double %507
%509 = call double @cbnd(double %496, double %506, double %508)
%510 = load double, double* %13
%511 = load double, double* %13
%512 = load double, double* %12
%513 = fdiv double %511, %512
%514 = load double, double* %17
%515 = fmul double -2.000000e+00, %514
%516 = load double, double* %20
%517 = fdiv double %515, %516
%518 = call double @pow(double %513, double %517)
%519 = fmul double %510, %518
%520 = load double, double* %28
%521 = load double, double* %29
%522 = load double, double* %23
%523 = call double @llvm.fmuladd.f64(double -2.000000e+00, double %522, double %521)
%524 = load double, double* %25
%525 = load double, double* %14
%526 = call double @llvm.fmuladd.f64(double %524, double %525, double %523)
%527 = fmul double %520, %526
%528 = load double, double* %19
%529 = fdiv double %527, %528
%530 = load double, double* %28
%531 = load double, double* %23
%532 = load double, double* %24
%533 = fneg double %532
%534 = call double @llvm.fmuladd.f64(double 2.000000e+00, double %531, double %533)
%535 = load double, double* %25
%536 = load double, double* %15
%537 = fneg double %535
%538 = call double @llvm.fmuladd.f64(double %537, double %536, double %534)
%539 = fmul double %530, %538
%540 = load double, double* %22
%541 = fdiv double %539, %540
%542 = load double, double* %27
%543 = fneg double %542
%544 = call double @cbnd(double %529, double %541, double %543)
%545 = fmul double %519, %544
%546 = fneg double %545
%547 = call double @llvm.fmuladd.f64(double %488, double %509, double %546)
%548 = fmul double %478, %547
store double %548, double* %41
%549 = load double, double* %11
%550 = load double, double* %17
%551 = load double, double* %16
%552 = fsub double %550, %551
%553 = load double, double* %15
%554 = fmul double %552, %553
%555 = call double @exp(double %554)
%556 = fmul double %549, %555
%557 = load double, double* %20
%558 = load double, double* %17
%559 = fmul double 2.000000e+00, %558
%560 = fdiv double %557, %559
%561 = fadd double 1.000000e+00, %560
%562 = load double, double* %28
%563 = load double, double* %26
%564 = fmul double %562, %563
%565 = load double, double* %15
%566 = load double, double* %14
%567 = fsub double %565, %566
%568 = fmul double %564, %567
%569 = load double, double* %18
%570 = load double, double* %15
%571 = load double, double* %14
%572 = fsub double %570, %571
%573 = call double @sqrt(double %572)
%574 = fmul double %569, %573
%575 = fdiv double %568, %574
%576 = call double @cnd(double %575)
%577 = load double, double* %17
%578 = fneg double %577
%579 = load double, double* %15
%580 = load double, double* %14
%581 = fsub double %579, %580
%582 = fmul double %578, %581
%583 = call double @exp(double %582)
%584 = load double, double* %20
%585 = load double, double* %17
%586 = fmul double 2.000000e+00, %585
%587 = fdiv double %584, %586
%588 = fsub double 1.000000e+00, %587
%589 = fmul double %583, %588
%590 = load double, double* %28
%591 = load double, double* %25
%592 = fneg double %591
%593 = load double, double* %15
%594 = load double, double* %14
%595 = fsub double %593, %594
%596 = fmul double %592, %595
%597 = fmul double %590, %596
%598 = load double, double* %18
%599 = load double, double* %15
%600 = load double, double* %14
%601 = fsub double %599, %600
%602 = call double @sqrt(double %601)
%603 = fmul double %598, %602
%604 = fdiv double %597, %603
%605 = call double @cnd(double %604)
%606 = fmul double %589, %605
%607 = call double @llvm.fmuladd.f64(double %561, double %576, double %606)
%608 = fmul double %556, %607
%609 = load double, double* %32
%610 = load double, double* %21
%611 = load double, double* %12
%612 = fmul double %610, %611
%613 = load double, double* %33
%614 = fmul double %612, %613
%615 = fneg double %614
%616 = call double @llvm.fmuladd.f64(double %608, double %609, double %615)
store double %616, double* %42
%617 = load double, double* %28
%618 = load double, double* %39
%619 = load double, double* %40
%620 = fadd double %618, %619
%621 = load double, double* %41
%622 = fadd double %620, %621
%623 = load double, double* %42
%624 = fadd double %622, %623
%625 = fmul double %617, %624
store double %625, double* %43
%626 = load i32, i32* %10
%627 = icmp eq i32 %626, 4
br i1 %627, label %631, label %628
628: ; preds = %203
%629 = load i32, i32* %10
%630 = icmp eq i32 %629, 6
br i1 %630, label %631, label %633
631: ; preds = %628, %203
%632 = load double, double* %43
store double %632, double* %44
br label %665
633: ; preds = %628
%634 = load i32, i32* %10
%635 = icmp eq i32 %634, 3
br i1 %635, label %636, label %647
636: ; preds = %633
%637 = load double, double* %11
%638 = load double, double* %12
%639 = load double, double* %14
%640 = load double, double* %15
%641 = load double, double* %16
%642 = load double, double* %17
%643 = load double, double* %18
%644 = call double @PartialFixedLB(i32 1, double %637, double %638, double %639, double %640, double %641, double %642, double %643)
%645 = load double, double* %43
%646 = fsub double %644, %645
store double %646, double* %44
br label %664
647: ; preds = %633
%648 = load i32, i32* %10
%649 = icmp eq i32 %648, 5
br i1 %649, label %650, label %661
650: ; preds = %647
%651 = load double, double* %11
%652 = load double, double* %12
%653 = load double, double* %14
%654 = load double, double* %15
%655 = load double, double* %16
%656 = load double, double* %17
%657 = load double, double* %18
%658 = call double @PartialFixedLB(i32 0, double %651, double %652, double %653, double %654, double %655, double %656, double %657)
%659 = load double, double* %43
%660 = fsub double %658, %659
store double %660, double* %44
br label %663
661: ; preds = %647
%662 = call i32 (...) @abort()
unreachable
663: ; preds = %650
br label %664
664: ; preds = %663, %636
br label %665
665: ; preds = %664, %631
%666 = load double, double* %44
ret double %666
}

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