double find_dadjFast(const unsigned i, const unsigned j, const unsigned nRows,
                     const float *obsloc[3], const float *rszloc[3],
                     const double readNoiseAmp) {
  const double mval = (double)*(rszloc[i] + j);
  const double dval0 = (double)*(obsloc[i] + j) - mval;
  double dval0u = dval0;
  if (dval0u > 1)
    dval0u = 1;
  else if (dval0u < -1)
    dval0u = -1;
  double dval9 = 0.0;
  if (i == 1 && j < nRows - 1 && j > 0) {
    dval9 =
        (double)*(obsloc[i] + j - 1) - (double)*(rszloc[i] + j - 1) +
        (double)*(obsloc[i] + j) - (double)*(rszloc[i] + j) +
        (double)*(obsloc[i] + j + 1) - (double)*(rszloc[i] + j + 1) +
        (double)*(obsloc[i - 1] + j - 1) - (double)*(rszloc[i - 1] + j - 1) +
        (double)*(obsloc[i - 1] + j) - (double)*(rszloc[i - 1] + j) +
        (double)*(obsloc[i - 1] + j + 1) - (double)*(rszloc[i - 1] + j + 1) +
        (double)*(obsloc[i + 1] + j - 1) - (double)*(rszloc[i + 1] + j - 1) +
        (double)*(obsloc[i + 1] + j) - (double)*(rszloc[i + 1] + j) +
        (double)*(obsloc[i + 1] + j + 1) - (double)*(rszloc[i + 1] + j + 1);
    dval9 = dval9 / 9.0;
  }
  const double readNoiseAmpFraction = 0.33;
  double dval9u = dval9;
  if (dval9u > readNoiseAmp * readNoiseAmpFraction)
    dval9u = readNoiseAmp * readNoiseAmpFraction;
  else if (dval9u < readNoiseAmp * -readNoiseAmpFraction)
    dval9u = readNoiseAmp * -readNoiseAmpFraction;
  const double dmod1 = j > 0 ? (double)*(rszloc[i] + j - 1) - mval : 0;
  const double dmod2 = j < nRows - 1 ? (double)*(rszloc[i] + j + 1) - mval : 0;
  double dmod1u = dmod1;
  if (dmod1u > readNoiseAmp * readNoiseAmpFraction)
    dmod1u = readNoiseAmp * readNoiseAmpFraction;
  else if (dmod1u < readNoiseAmp * -readNoiseAmpFraction)
    dmod1u = readNoiseAmp * -readNoiseAmpFraction;
  double dmod2u = dmod2;
  if (dmod2u > readNoiseAmp * readNoiseAmpFraction)
    dmod2u = readNoiseAmp * readNoiseAmpFraction;
  else if (dmod2u < readNoiseAmp * -readNoiseAmpFraction)
    dmod2u = readNoiseAmp * -readNoiseAmpFraction;
  const double readNoiseAmp2 = readNoiseAmp * readNoiseAmp;
  const double w0 = dval0 * dval0 / (dval0 * dval0 + 4.0 * readNoiseAmp2);
  const double w9 = dval9 * dval9 / (dval9 * dval9 + 18.0 * readNoiseAmp2);
  const double w1 = 4 * readNoiseAmp2 / (dmod1 * dmod1 + 4.0 * readNoiseAmp2);
  const double w2 = 4 * readNoiseAmp2 / (dmod2 * dmod2 + 4.0 * readNoiseAmp2);
  return dval0u * w0 * 0.25f + dval9u * w9 * 0.25f + dmod1u * w1 * 0.25f +
         dmod2u * w2 * 0.25f;
}


x86 assembly (clang, -O0):
<find_dadjFast>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
movsd  %xmm0,-0x28(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x4(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x8(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x4(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x8(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
subsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x40(%rbp),%xmm0
movsd  0xe8e(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    118e <find_dadjFast+0x8e>
movsd  0xe7c(%rip),%xmm0
movsd  %xmm0,-0x40(%rbp)
jmp    11b3 <find_dadjFast+0xb3>
movsd  0xe72(%rip),%xmm0
ucomisd -0x40(%rbp),%xmm0
jbe    11ae <find_dadjFast+0xae>
movsd  0xe5f(%rip),%xmm0
movsd  %xmm0,-0x40(%rbp)
jmp    11b3 <find_dadjFast+0xb3>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
cmpl   $0x1,-0x4(%rbp)
jne    1425 <find_dadjFast+0x325>
mov    -0x8(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jae    1425 <find_dadjFast+0x325>
cmpl   $0x0,-0x8(%rbp)
jbe    1425 <find_dadjFast+0x325>
mov    -0x18(%rbp),%rax
mov    -0x4(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x8(%rbp),%ecx
movss  -0x4(%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x4(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x8(%rbp),%ecx
movss  -0x4(%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
subsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x4(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x8(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x4(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x8(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
subsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x4(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x8(%rbp),%ecx
movss  0x4(%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x4(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x8(%rbp),%ecx
movss  0x4(%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
subsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x8(%rbp),%ecx
movss  -0x4(%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x8(%rbp),%ecx
movss  -0x4(%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
subsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x8(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x8(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
subsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x8(%rbp),%ecx
movss  0x4(%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x8(%rbp),%ecx
movss  0x4(%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
subsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x8(%rbp),%ecx
movss  -0x4(%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x8(%rbp),%ecx
movss  -0x4(%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
subsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x8(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x8(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
subsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x8(%rbp),%ecx
movss  0x4(%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x8(%rbp),%ecx
movss  0x4(%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
movsd  0xbf4(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  0xbeb(%rip),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
movsd  0xbcf(%rip),%xmm1
mulsd  -0x28(%rbp),%xmm1
ucomisd %xmm1,%xmm0
jbe    146f <find_dadjFast+0x36f>
movsd  0xbb8(%rip),%xmm0
mulsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
jmp    14a2 <find_dadjFast+0x3a2>
movsd  -0x58(%rbp),%xmm1
movsd  0xba4(%rip),%xmm0
mulsd  -0x28(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    149d <find_dadjFast+0x39d>
movsd  0xb8d(%rip),%xmm0
mulsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
jmp    14a2 <find_dadjFast+0x3a2>
cmpl   $0x0,-0x8(%rbp)
jbe    14d6 <find_dadjFast+0x3d6>
mov    -0x20(%rbp),%rax
mov    -0x4(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x8(%rbp),%ecx
movss  -0x4(%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
subsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
jmp    14e6 <find_dadjFast+0x3e6>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
jmp    14e6 <find_dadjFast+0x3e6>
movsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x60(%rbp)
mov    -0x8(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jae    152e <find_dadjFast+0x42e>
mov    -0x20(%rbp),%rax
mov    -0x4(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x8(%rbp),%ecx
movss  0x4(%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
subsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
jmp    153e <find_dadjFast+0x43e>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
jmp    153e <find_dadjFast+0x43e>
movsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0x68(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm0
movsd  0xab6(%rip),%xmm1
mulsd  -0x28(%rbp),%xmm1
ucomisd %xmm1,%xmm0
jbe    1588 <find_dadjFast+0x488>
movsd  0xa9f(%rip),%xmm0
mulsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
jmp    15bb <find_dadjFast+0x4bb>
movsd  -0x70(%rbp),%xmm1
movsd  0xa8b(%rip),%xmm0
mulsd  -0x28(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    15b6 <find_dadjFast+0x4b6>
movsd  0xa74(%rip),%xmm0
mulsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
jmp    15bb <find_dadjFast+0x4bb>
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
movsd  0xa46(%rip),%xmm1
mulsd  -0x28(%rbp),%xmm1
ucomisd %xmm1,%xmm0
jbe    15f8 <find_dadjFast+0x4f8>
movsd  0xa2f(%rip),%xmm0
mulsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
jmp    162b <find_dadjFast+0x52b>
movsd  -0x78(%rbp),%xmm1
movsd  0xa1b(%rip),%xmm0
mulsd  -0x28(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1626 <find_dadjFast+0x526>
movsd  0xa04(%rip),%xmm0
mulsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
jmp    162b <find_dadjFast+0x52b>
movsd  -0x28(%rbp),%xmm0
mulsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x38(%rbp),%xmm0
mulsd  -0x38(%rbp),%xmm0
movsd  -0x38(%rbp),%xmm1
movsd  -0x38(%rbp),%xmm3
movsd  0x9da(%rip),%xmm2
mulsd  -0x80(%rbp),%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x48(%rbp),%xmm0
mulsd  -0x48(%rbp),%xmm0
movsd  -0x48(%rbp),%xmm1
movsd  -0x48(%rbp),%xmm3
movsd  0x9ad(%rip),%xmm2
mulsd  -0x80(%rbp),%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  0x984(%rip),%xmm0
mulsd  -0x80(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm1
movsd  -0x60(%rbp),%xmm3
movsd  0x96d(%rip),%xmm2
mulsd  -0x80(%rbp),%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  0x94c(%rip),%xmm0
mulsd  -0x80(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm1
movsd  -0x68(%rbp),%xmm3
movsd  0x935(%rip),%xmm2
mulsd  -0x80(%rbp),%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x40(%rbp),%xmm0
mulsd  -0x88(%rbp),%xmm0
ff
movsd  -0x58(%rbp),%xmm1
mulsd  -0x90(%rbp),%xmm1
ff
movsd  0x8f2(%rip),%xmm2
mulsd  %xmm2,%xmm1
movsd  0x8e6(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x70(%rbp),%xmm1
mulsd  -0x98(%rbp),%xmm1
ff
movsd  0x8c9(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x78(%rbp),%xmm0
mulsd  -0xa0(%rbp),%xmm0
ff
movsd  0x8ac(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<find_dadjFast>:
mov    %edi,%eax
mov    (%r8,%rax,8),%r9
mov    %esi,%r11d
movss  (%r9,%r11,4),%xmm1
cvtss2sd %xmm1,%xmm1
mov    (%rcx,%rax,8),%r10
movss  (%r10,%r11,4),%xmm2
cvtss2sd %xmm2,%xmm3
movaps %xmm3,%xmm7
subsd  %xmm1,%xmm7
movsd  0xecf(%rip),%xmm8
ucomisd %xmm8,%xmm7
ja     1150 <find_dadjFast+0x50>
movsd  0xec8(%rip),%xmm4
ucomisd %xmm7,%xmm4
movapd %xmm7,%xmm8
jbe    1150 <find_dadjFast+0x50>
movapd %xmm4,%xmm8
xorpd  %xmm4,%xmm4
cmp    $0x1,%edi
jne    1288 <find_dadjFast+0x188>
test   %esi,%esi
je     1288 <find_dadjFast+0x188>
lea    -0x1(%rdx),%eax
cmp    %esi,%eax
jbe    1288 <find_dadjFast+0x188>
movss  -0x4(%r10,%r11,4),%xmm4
movss  0x4(%r10,%r11,4),%xmm5
cvtss2sd %xmm4,%xmm4
movss  -0x4(%r9,%r11,4),%xmm6
movss  0x4(%r9,%r11,4),%xmm2
cvtss2sd %xmm6,%xmm6
subsd  %xmm6,%xmm4
addsd  %xmm3,%xmm4
subsd  %xmm1,%xmm4
xorps  %xmm3,%xmm3
cvtss2sd %xmm5,%xmm3
addsd  %xmm4,%xmm3
xorps  %xmm4,%xmm4
cvtss2sd %xmm2,%xmm4
subsd  %xmm4,%xmm3
mov    (%rcx),%rax
mov    0x10(%rcx),%r10
movss  -0x4(%rax,%r11,4),%xmm4
movss  (%rax,%r11,4),%xmm5
cvtss2sd %xmm4,%xmm4
addsd  %xmm3,%xmm4
mov    (%r8),%rcx
mov    0x10(%r8),%rdi
movss  -0x4(%rcx,%r11,4),%xmm3
movss  (%rcx,%r11,4),%xmm6
cvtss2sd %xmm3,%xmm3
subsd  %xmm3,%xmm4
xorps  %xmm3,%xmm3
cvtss2sd %xmm5,%xmm3
addsd  %xmm4,%xmm3
xorps  %xmm4,%xmm4
cvtss2sd %xmm6,%xmm4
subsd  %xmm4,%xmm3
movss  0x4(%rax,%r11,4),%xmm4
cvtss2sd %xmm4,%xmm4
addsd  %xmm3,%xmm4
movss  0x4(%rcx,%r11,4),%xmm3
cvtss2sd %xmm3,%xmm3
subsd  %xmm3,%xmm4
movss  -0x4(%r10,%r11,4),%xmm3
movss  (%r10,%r11,4),%xmm5
cvtss2sd %xmm3,%xmm3
addsd  %xmm4,%xmm3
movss  -0x4(%rdi,%r11,4),%xmm4
movss  (%rdi,%r11,4),%xmm6
cvtss2sd %xmm4,%xmm4
subsd  %xmm4,%xmm3
cvtss2sd %xmm5,%xmm5
addsd  %xmm3,%xmm5
xorps  %xmm3,%xmm3
cvtss2sd %xmm6,%xmm3
subsd  %xmm3,%xmm5
movss  0x4(%r10,%r11,4),%xmm3
xorps  %xmm4,%xmm4
cvtss2sd %xmm3,%xmm4
addsd  %xmm5,%xmm4
movss  0x4(%rdi,%r11,4),%xmm3
cvtss2sd %xmm3,%xmm3
subsd  %xmm3,%xmm4
divsd  0xd88(%rip),%xmm4
movsd  0xd88(%rip),%xmm5
mulsd  %xmm0,%xmm5
ucomisd %xmm5,%xmm4
movapd %xmm5,%xmm9
ja     12bb <find_dadjFast+0x1bb>
movsd  0xd79(%rip),%xmm3
mulsd  %xmm0,%xmm3
ucomisd %xmm4,%xmm3
movapd %xmm4,%xmm9
jbe    12bb <find_dadjFast+0x1bb>
movapd %xmm3,%xmm9
xorps  %xmm6,%xmm6
xorpd  %xmm3,%xmm3
test   %esi,%esi
je     12d5 <find_dadjFast+0x1d5>
movss  -0x4(%r9,%r11,4),%xmm3
cvtss2sd %xmm3,%xmm3
subsd  %xmm1,%xmm3
add    $0xffffffff,%edx
cmp    %esi,%edx
jbe    12eb <find_dadjFast+0x1eb>
movss  0x4(%r9,%r11,4),%xmm6
cvtss2sd %xmm6,%xmm6
subsd  %xmm1,%xmm6
ucomisd %xmm5,%xmm3
movapd %xmm5,%xmm10
ja     1312 <find_dadjFast+0x212>
movsd  0xd22(%rip),%xmm1
mulsd  %xmm0,%xmm1
ucomisd %xmm3,%xmm1
movapd %xmm3,%xmm10
jbe    1312 <find_dadjFast+0x212>
movapd %xmm1,%xmm10
ucomisd %xmm5,%xmm6
ja     1332 <find_dadjFast+0x232>
movsd  0xd00(%rip),%xmm1
mulsd  %xmm0,%xmm1
ucomisd %xmm6,%xmm1
movapd %xmm6,%xmm5
jbe    1332 <find_dadjFast+0x232>
movapd %xmm1,%xmm5
mulsd  %xmm0,%xmm0
mulsd  %xmm7,%xmm7
movsd  0xce6(%rip),%xmm1
mulsd  %xmm0,%xmm1
movapd %xmm7,%xmm2
addsd  %xmm1,%xmm2
divsd  %xmm2,%xmm7
mulsd  %xmm8,%xmm7
mulsd  0xcd1(%rip),%xmm0
mulsd  %xmm4,%xmm4
addsd  %xmm4,%xmm0
divsd  %xmm0,%xmm4
mulsd  %xmm9,%xmm4
mulsd  %xmm3,%xmm3
addsd  %xmm1,%xmm3
movapd %xmm1,%xmm0
divsd  %xmm3,%xmm0
mulsd  %xmm10,%xmm0
mulsd  %xmm6,%xmm6
addsd  %xmm1,%xmm6
divsd  %xmm6,%xmm1
mulsd  %xmm5,%xmm1
movsd  0xc9b(%rip),%xmm2
mulsd  %xmm2,%xmm4
mulsd  %xmm2,%xmm7
addsd  %xmm4,%xmm7
mulsd  %xmm2,%xmm0
addsd  %xmm7,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movapd %xmm1,%xmm0
ret

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

LLVM IR (-O2):
define double @find_dadjFast(i32 %0, i32 %1, i32 %2, float** nocapture %3, float** nocapture %4, double %5) {
%7 = zext i32 %0 to i64
%8 = getelementptr inbounds float*, float** %4, i64 %7
%9 = load float*, float** %8
%10 = zext i32 %1 to i64
%11 = getelementptr inbounds float, float* %9, i64 %10
%12 = load float, float* %11
%13 = fpext float %12 to double
%14 = getelementptr inbounds float*, float** %3, i64 %7
%15 = load float*, float** %14
%16 = getelementptr inbounds float, float* %15, i64 %10
%17 = load float, float* %16
%18 = fpext float %17 to double
%19 = fsub double %18, %13
%20 = fcmp ogt double %19, 1.000000e+00
br i1 %20, label %24, label %21
21: ; preds = %6
%22 = fcmp olt double %19, -1.000000e+00
br i1 %22, label %23, label %24
23: ; preds = %21
br label %24
24: ; preds = %6, %21, %23
%25 = phi double [ -1.000000e+00, %23 ], [ %19, %21 ], [ 1.000000e+00, %6 ]
%26 = icmp eq i32 %0, 1
br i1 %26, label %27, label %105
27: ; preds = %24
%28 = add i32 %2, -1
%29 = icmp ugt i32 %28, %1
%30 = icmp ne i32 %1, 0
%31 = and i1 %30, %29
br i1 %31, label %32, label %105
32: ; preds = %27
%33 = getelementptr inbounds float, float* %16, i64 -1
%34 = load float, float* %33
%35 = fpext float %34 to double
%36 = getelementptr inbounds float, float* %11, i64 -1
%37 = load float, float* %36
%38 = fpext float %37 to double
%39 = fsub double %35, %38
%40 = fadd double %39, %18
%41 = fsub double %40, %13
%42 = getelementptr inbounds float, float* %16, i64 1
%43 = load float, float* %42
%44 = fpext float %43 to double
%45 = fadd double %41, %44
%46 = getelementptr inbounds float, float* %11, i64 1
%47 = load float, float* %46
%48 = fpext float %47 to double
%49 = fsub double %45, %48
%50 = load float*, float** %3
%51 = getelementptr inbounds float, float* %50, i64 %10
%52 = getelementptr inbounds float, float* %51, i64 -1
%53 = load float, float* %52
%54 = fpext float %53 to double
%55 = fadd double %49, %54
%56 = load float*, float** %4
%57 = getelementptr inbounds float, float* %56, i64 %10
%58 = getelementptr inbounds float, float* %57, i64 -1
%59 = load float, float* %58
%60 = fpext float %59 to double
%61 = fsub double %55, %60
%62 = load float, float* %51
%63 = fpext float %62 to double
%64 = fadd double %61, %63
%65 = load float, float* %57
%66 = fpext float %65 to double
%67 = fsub double %64, %66
%68 = getelementptr inbounds float, float* %51, i64 1
%69 = load float, float* %68
%70 = fpext float %69 to double
%71 = fadd double %67, %70
%72 = getelementptr inbounds float, float* %57, i64 1
%73 = load float, float* %72
%74 = fpext float %73 to double
%75 = fsub double %71, %74
%76 = getelementptr inbounds float*, float** %3, i64 2
%77 = load float*, float** %76
%78 = getelementptr inbounds float, float* %77, i64 %10
%79 = getelementptr inbounds float, float* %78, i64 -1
%80 = load float, float* %79
%81 = fpext float %80 to double
%82 = fadd double %75, %81
%83 = getelementptr inbounds float*, float** %4, i64 2
%84 = load float*, float** %83
%85 = getelementptr inbounds float, float* %84, i64 %10
%86 = getelementptr inbounds float, float* %85, i64 -1
%87 = load float, float* %86
%88 = fpext float %87 to double
%89 = fsub double %82, %88
%90 = load float, float* %78
%91 = fpext float %90 to double
%92 = fadd double %89, %91
%93 = load float, float* %85
%94 = fpext float %93 to double
%95 = fsub double %92, %94
%96 = getelementptr inbounds float, float* %78, i64 1
%97 = load float, float* %96
%98 = fpext float %97 to double
%99 = fadd double %95, %98
%100 = getelementptr inbounds float, float* %85, i64 1
%101 = load float, float* %100
%102 = fpext float %101 to double
%103 = fsub double %99, %102
%104 = fdiv double %103, 9.000000e+00
br label %105
105: ; preds = %32, %27, %24
%106 = phi double [ %104, %32 ], [ 0.000000e+00, %27 ], [ 0.000000e+00, %24 ]
%107 = fmul double %5, 3.300000e-01
%108 = fcmp ogt double %106, %107
br i1 %108, label %113, label %109
109: ; preds = %105
%110 = fmul double %5, -3.300000e-01
%111 = fcmp olt double %106, %110
br i1 %111, label %112, label %113
112: ; preds = %109
br label %113
113: ; preds = %105, %109, %112
%114 = phi double [ %110, %112 ], [ %106, %109 ], [ %107, %105 ]
%115 = icmp eq i32 %1, 0
br i1 %115, label %121, label %116
116: ; preds = %113
%117 = getelementptr inbounds float, float* %11, i64 -1
%118 = load float, float* %117
%119 = fpext float %118 to double
%120 = fsub double %119, %13
br label %121
121: ; preds = %113, %116
%122 = phi double [ %120, %116 ], [ 0.000000e+00, %113 ]
%123 = add i32 %2, -1
%124 = icmp ugt i32 %123, %1
br i1 %124, label %125, label %130
125: ; preds = %121
%126 = getelementptr inbounds float, float* %11, i64 1
%127 = load float, float* %126
%128 = fpext float %127 to double
%129 = fsub double %128, %13
br label %130
130: ; preds = %121, %125
%131 = phi double [ %129, %125 ], [ 0.000000e+00, %121 ]
%132 = fcmp ogt double %122, %107
br i1 %132, label %137, label %133
133: ; preds = %130
%134 = fmul double %5, -3.300000e-01
%135 = fcmp olt double %122, %134
br i1 %135, label %136, label %137
136: ; preds = %133
br label %137
137: ; preds = %130, %133, %136
%138 = phi double [ %134, %136 ], [ %122, %133 ], [ %107, %130 ]
%139 = fcmp ogt double %131, %107
br i1 %139, label %144, label %140
140: ; preds = %137
%141 = fmul double %5, -3.300000e-01
%142 = fcmp olt double %131, %141
br i1 %142, label %143, label %144
143: ; preds = %140
br label %144
144: ; preds = %137, %140, %143
%145 = phi double [ %141, %143 ], [ %131, %140 ], [ %107, %137 ]
%146 = fmul double %5, %5
%147 = fmul double %19, %19
%148 = fmul double %146, 4.000000e+00
%149 = tail call double @llvm.fmuladd.f64(double %19, double %19, double %148)
%150 = fdiv double %147, %149
%151 = fmul double %106, %106
%152 = fmul double %146, 1.800000e+01
%153 = tail call double @llvm.fmuladd.f64(double %106, double %106, double %152)
%154 = fdiv double %151, %153
%155 = tail call double @llvm.fmuladd.f64(double %122, double %122, double %148)
%156 = fdiv double %148, %155
%157 = tail call double @llvm.fmuladd.f64(double %131, double %131, double %148)
%158 = fdiv double %148, %157
%159 = fmul double %150, %25
%160 = fmul double %154, %114
%161 = fmul double %160, 2.500000e-01
%162 = tail call double @llvm.fmuladd.f64(double %159, double 2.500000e-01, double %161)
%163 = fmul double %156, %138
%164 = tail call double @llvm.fmuladd.f64(double %163, double 2.500000e-01, double %162)
%165 = fmul double %158, %145
%166 = tail call double @llvm.fmuladd.f64(double %165, double 2.500000e-01, double %164)
ret double %166
}