void estimate_ncf(double q_est[4], double b_est[3], const double omega[3],
                  const double acc[3], double kp, double dt) {
  double wx;
  double wy;
  double wz;
  double dv0[16];
  double dv1[16];
  int k;
  int i0;
  double dv2[4];
  double t;
  double Rbe[9];
  double b_Rbe[9];
  double c_Rbe[3];
  double b[3];
  static const double b_b[3] = {0.0, 0.0, -9.81};
  double a[3];
  wx = omega[0] + b_est[0];
  wy = omega[1] + b_est[1];
  wz = omega[2] + b_est[2];
  dv0[0] = 0.0;
  dv0[4] = -wx;
  dv0[8] = -wy;
  dv0[12] = -wz;
  dv0[1] = wx;
  dv0[5] = 0.0;
  dv0[9] = wz;
  dv0[13] = -wy;
  dv0[2] = wy;
  dv0[6] = -wz;
  dv0[10] = 0.0;
  dv0[14] = wx;
  dv0[3] = wz;
  dv0[7] = wy;
  dv0[11] = -wx;
  dv0[15] = 0.0;
  for (k = 0; k < 4; k++) {
    for (i0 = 0; i0 < 4; i0++) {
      dv1[i0 + (k << 2)] = 0.5 * dv0[i0 + (k << 2)];
    }
  }
  for (k = 0; k < 4; k++) {
    dv2[k] = 0.0;
    for (i0 = 0; i0 < 4; i0++) {
      wx = dv2[k] + dv1[k + (i0 << 2)] * q_est[i0];
      dv2[k] = wx;
    }
  }
  for (k = 0; k < 4; k++) {
    q_est[k] += dv2[k] * dt;
  }
  wx = 0.0;
  wy = 2.2250738585072014E-308;
  for (k = 0; k < 4; k++) {
    wz = fabs(q_est[k]);
    if (wz > wy) {
      t = wy / wz;
      wx = 1.0 + wx * t * t;
      wy = wz;
    } else {
      t = wz / wy;
      wx += t * t;
    }
  }
  wx = wy * sqrt(wx);
  for (k = 0; k < 4; k++) {
    q_est[k] /= wx;
  }
  Rbe[0] = ((q_est[0] * q_est[0] + q_est[1] * q_est[1]) - q_est[2] * q_est[2]) -
           q_est[3] * q_est[3];
  Rbe[3] = 2.0 * (q_est[1] * q_est[2] + q_est[0] * q_est[3]);
  Rbe[6] = 2.0 * (q_est[1] * q_est[3] - q_est[0] * q_est[2]);
  Rbe[1] = 2.0 * (q_est[1] * q_est[2] - q_est[0] * q_est[3]);
  Rbe[4] = ((q_est[0] * q_est[0] - q_est[1] * q_est[1]) + q_est[2] * q_est[2]) -
           q_est[3] * q_est[3];
  Rbe[7] = 2.0 * (q_est[2] * q_est[3] + q_est[0] * q_est[1]);
  Rbe[2] = 2.0 * (q_est[1] * q_est[3] + q_est[0] * q_est[2]);
  Rbe[5] = 2.0 * (q_est[2] * q_est[3] - q_est[0] * q_est[1]);
  Rbe[8] = ((q_est[0] * q_est[0] - q_est[1] * q_est[1]) - q_est[2] * q_est[2]) +
           q_est[3] * q_est[3];
  for (k = 0; k < 3; k++) {
    for (i0 = 0; i0 < 3; i0++) {
      b_Rbe[i0 + 3 * k] = -Rbe[i0 + 3 * k];
    }
  }
  for (k = 0; k < 3; k++) {
    c_Rbe[k] = 0.0;
    for (i0 = 0; i0 < 3; i0++) {
      c_Rbe[k] += b_Rbe[k + 3 * i0] * b_b[i0];
    }
    b[k] = c_Rbe[k];
  }
  a[0] = acc[1] * b[2] - acc[2] * b[1];
  a[1] = acc[2] * b[0] - acc[0] * b[2];
  a[2] = acc[0] * b[1] - acc[1] * b[0];
  for (k = 0; k < 3; k++) {
    b_est[k] = kp * (0.5 * a[k]);
  }
}


x86 assembly (clang, -O0):
<estimate_ncf>:
push   %rbp
mov    %rsp,%rbp
sub    $0x290,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
movsd  %xmm0,-0x28(%rbp)
movsd  %xmm1,-0x30(%rbp)
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
addsd  (%rax),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x18(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
addsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
addsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x48(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x38(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x40(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x48(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x40(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0x48(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x38(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x78(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0x154(%rbp)
cmpl   $0x4,-0x154(%rbp)
jge    1353 <estimate_ncf+0x243>
movl   $0x0,-0x158(%rbp)
cmpl   $0x4,-0x158(%rbp)
jge    133a <estimate_ncf+0x22a>
mov    -0x158(%rbp),%eax
mov    -0x154(%rbp),%ecx
shl    $0x2,%ecx
add    %ecx,%eax
cltq
movsd  0xd0f(%rip),%xmm0
mulsd  -0xd0(%rbp,%rax,8),%xmm0
ff ff
mov    -0x158(%rbp),%eax
mov    -0x154(%rbp),%ecx
shl    $0x2,%ecx
add    %ecx,%eax
cltq
movsd  %xmm0,-0x150(%rbp,%rax,8)
ff ff
mov    -0x158(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x158(%rbp)
jmp    12d9 <estimate_ncf+0x1c9>
jmp    133f <estimate_ncf+0x22f>
mov    -0x154(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x154(%rbp)
jmp    12c2 <estimate_ncf+0x1b2>
movl   $0x0,-0x154(%rbp)
cmpl   $0x4,-0x154(%rbp)
jge    141f <estimate_ncf+0x30f>
movslq -0x154(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x180(%rbp,%rax,8)
ff ff
movl   $0x0,-0x158(%rbp)
cmpl   $0x4,-0x158(%rbp)
jge    1406 <estimate_ncf+0x2f6>
movslq -0x154(%rbp),%rax
movsd  -0x180(%rbp,%rax,8),%xmm1
ff ff
mov    -0x154(%rbp),%eax
mov    -0x158(%rbp),%ecx
shl    $0x2,%ecx
add    %ecx,%eax
cltq
movsd  -0x150(%rbp,%rax,8),%xmm0
ff ff
mov    -0x8(%rbp),%rax
movslq -0x158(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x38(%rbp),%xmm0
movslq -0x154(%rbp),%rax
movsd  %xmm0,-0x180(%rbp,%rax,8)
ff ff
mov    -0x158(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x158(%rbp)
jmp    1387 <estimate_ncf+0x277>
jmp    140b <estimate_ncf+0x2fb>
mov    -0x154(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x154(%rbp)
jmp    135d <estimate_ncf+0x24d>
movl   $0x0,-0x154(%rbp)
cmpl   $0x4,-0x154(%rbp)
jge    147c <estimate_ncf+0x36c>
movslq -0x154(%rbp),%rax
movsd  -0x180(%rbp,%rax,8),%xmm0
ff ff
movsd  -0x30(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x154(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x154(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x154(%rbp)
jmp    1429 <estimate_ncf+0x319>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  0xb74(%rip),%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x0,-0x154(%rbp)
cmpl   $0x4,-0x154(%rbp)
jge    1570 <estimate_ncf+0x460>
mov    -0x8(%rbp),%rax
movslq -0x154(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xb61(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
ucomisd -0x40(%rbp),%xmm0
jbe    1523 <estimate_ncf+0x413>
movsd  -0x40(%rbp),%xmm0
divsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x188(%rbp)
ff
movsd  -0x38(%rbp),%xmm0
mulsd  -0x188(%rbp),%xmm0
ff
movsd  -0x188(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  0xb0d(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
jmp    1557 <estimate_ncf+0x447>
movsd  -0x48(%rbp),%xmm0
divsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x188(%rbp)
ff
movsd  -0x188(%rbp),%xmm0
ff
movsd  -0x188(%rbp),%xmm2
ff
movsd  -0x38(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
jmp    155c <estimate_ncf+0x44c>
mov    -0x154(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x154(%rbp)
jmp    149b <estimate_ncf+0x38b>
movsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x288(%rbp)
ff
movsd  -0x38(%rbp),%xmm0
call   1030 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0x288(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
movl   $0x0,-0x154(%rbp)
cmpl   $0x4,-0x154(%rbp)
jge    15e4 <estimate_ncf+0x4d4>
movsd  -0x38(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x154(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x154(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x154(%rbp)
jmp    15a5 <estimate_ncf+0x495>
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulsd  0x8(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1d0(%rbp)
ff
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x8(%rbp),%rax
mulsd  0x18(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x95d(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x1b8(%rbp)
ff
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x8(%rbp),%rax
mulsd  0x10(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x907(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x1a0(%rbp)
ff
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x8(%rbp),%rax
mulsd  0x18(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x8b1(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x1c8(%rbp)
ff
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulsd  0x8(%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1b0(%rbp)
ff
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x8(%rbp),%rax
mulsd  0x8(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x7de(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x198(%rbp)
ff
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x8(%rbp),%rax
mulsd  0x10(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x79f(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x1c0(%rbp)
ff
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x8(%rbp),%rax
mulsd  0x8(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x749(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x1a8(%rbp)
ff
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulsd  0x8(%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x190(%rbp)
ff
movl   $0x0,-0x154(%rbp)
cmpl   $0x3,-0x154(%rbp)
jge    1a05 <estimate_ncf+0x8f5>
movl   $0x0,-0x158(%rbp)
cmpl   $0x3,-0x158(%rbp)
jge    19ec <estimate_ncf+0x8dc>
mov    -0x158(%rbp),%eax
imul   $0x3,-0x154(%rbp),%ecx
add    %ecx,%eax
cltq
movsd  -0x1d0(%rbp,%rax,8),%xmm0
ff ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x158(%rbp),%eax
imul   $0x3,-0x154(%rbp),%ecx
add    %ecx,%eax
cltq
movsd  %xmm0,-0x220(%rbp,%rax,8)
ff ff
mov    -0x158(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x158(%rbp)
jmp    1980 <estimate_ncf+0x870>
jmp    19f1 <estimate_ncf+0x8e1>
mov    -0x154(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x154(%rbp)
jmp    1969 <estimate_ncf+0x859>
movl   $0x0,-0x154(%rbp)
cmpl   $0x3,-0x154(%rbp)
jge    1adc <estimate_ncf+0x9cc>
movslq -0x154(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x240(%rbp,%rax,8)
ff ff
movl   $0x0,-0x158(%rbp)
cmpl   $0x3,-0x158(%rbp)
jge    1aa8 <estimate_ncf+0x998>
mov    -0x154(%rbp),%eax
imul   $0x3,-0x158(%rbp),%ecx
add    %ecx,%eax
cltq
movsd  -0x220(%rbp,%rax,8),%xmm0
ff ff
movslq -0x158(%rbp),%rcx
lea    0x5c2(%rip),%rax
movsd  (%rax,%rcx,8),%xmm2
movslq -0x154(%rbp),%rax
movsd  -0x240(%rbp,%rax,8),%xmm1
ff ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x240(%rbp,%rax,8)
ff ff
mov    -0x158(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x158(%rbp)
jmp    1a39 <estimate_ncf+0x929>
movslq -0x154(%rbp),%rax
movsd  -0x240(%rbp,%rax,8),%xmm0
ff ff
movslq -0x154(%rbp),%rax
movsd  %xmm0,-0x260(%rbp,%rax,8)
ff ff
mov    -0x154(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x154(%rbp)
jmp    1a0f <estimate_ncf+0x8ff>
mov    -0x20(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  -0x250(%rbp),%xmm2
ff
mov    -0x20(%rbp),%rax
movsd  0x10(%rax),%xmm1
mulsd  -0x258(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x280(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  -0x260(%rbp),%xmm2
ff
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm1
mulsd  -0x250(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x278(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm0
movsd  -0x258(%rbp),%xmm2
ff
mov    -0x20(%rbp),%rax
movsd  0x8(%rax),%xmm1
mulsd  -0x260(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x270(%rbp)
ff
movl   $0x0,-0x154(%rbp)
cmpl   $0x3,-0x154(%rbp)
jge    1c11 <estimate_ncf+0xb01>
movsd  -0x28(%rbp),%xmm0
movslq -0x154(%rbp),%rax
movsd  0x430(%rip),%xmm1
mulsd  -0x280(%rbp,%rax,8),%xmm1
ff ff
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x154(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x154(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x154(%rbp)
jmp    1bbf <estimate_ncf+0xaaf>
add    $0x290,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<estimate_ncf>:
push   %r15
push   %r14
push   %rbx
sub    $0x20,%rsp
mov    %rsi,%r15
movsd  (%rdx),%xmm9
addsd  (%rsi),%xmm9
movapd %xmm0,%xmm15
mov    %rcx,%r14
mov    %rdi,%rbx
movupd 0x8(%rdx),%xmm2
movupd 0x8(%rsi),%xmm0
addpd  %xmm2,%xmm0
movsd  0xeb9(%rip),%xmm3
mulsd  %xmm9,%xmm3
movapd 0xeeb(%rip),%xmm8
mulpd  %xmm0,%xmm8
mulsd  0xea5(%rip),%xmm9
movapd 0xee4(%rip),%xmm10
mulpd  %xmm0,%xmm10
movapd %xmm10,%xmm11
shufpd $0x1,%xmm10,%xmm11
movupd (%rdi),%xmm5
movupd 0x10(%rdi),%xmm12
movapd %xmm5,%xmm2
unpcklpd %xmm3,%xmm2
xorpd  %xmm7,%xmm7
xorpd  %xmm4,%xmm4
unpcklpd %xmm5,%xmm4
mulpd  %xmm2,%xmm4
addpd  %xmm7,%xmm4
movapd %xmm5,%xmm2
movsd  %xmm9,%xmm2
movapd %xmm5,%xmm6
unpckhpd %xmm7,%xmm6
mulpd  %xmm2,%xmm6
addpd  %xmm4,%xmm6
mulpd  0xe9d(%rip),%xmm0
movapd %xmm12,%xmm2
unpcklpd %xmm12,%xmm2
mulpd  %xmm0,%xmm2
addpd  %xmm6,%xmm2
movapd %xmm12,%xmm0
unpckhpd %xmm12,%xmm0
mulpd  %xmm11,%xmm0
addpd  %xmm2,%xmm0
movapd %xmm5,%xmm4
unpcklpd %xmm1,%xmm1
mulpd  %xmm1,%xmm0
addpd  %xmm5,%xmm0
unpcklpd %xmm5,%xmm5
mulpd  %xmm8,%xmm5
addpd  %xmm7,%xmm5
shufpd $0x1,%xmm8,%xmm10
unpckhpd %xmm4,%xmm4
mulpd  %xmm10,%xmm4
addpd  %xmm5,%xmm4
movapd %xmm12,%xmm2
unpcklpd %xmm9,%xmm2
movapd %xmm12,%xmm5
unpckhpd %xmm7,%xmm5
unpcklpd %xmm12,%xmm7
mulpd  %xmm2,%xmm7
addpd  %xmm4,%xmm7
shufpd $0x2,%xmm12,%xmm3
mulpd  %xmm5,%xmm3
addpd  %xmm7,%xmm3
movupd %xmm0,(%rdi)
mulpd  %xmm3,%xmm1
addpd  %xmm12,%xmm1
movupd %xmm1,0x10(%rdi)
movapd 0xe10(%rip),%xmm4
andpd  %xmm0,%xmm4
ucomisd 0xda4(%rip),%xmm4
jbe    1290 <estimate_ncf+0x180>
movsd  0xd9a(%rip),%xmm3
divsd  %xmm4,%xmm3
xorpd  %xmm2,%xmm2
mulsd  %xmm3,%xmm2
mulsd  %xmm3,%xmm2
addsd  0xd92(%rip),%xmm2
jmp    12b0 <estimate_ncf+0x1a0>
movsd  0xd80(%rip),%xmm3
mulsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm3
xorpd  %xmm2,%xmm2
addsd  %xmm3,%xmm2
movsd  0xd60(%rip),%xmm4
unpckhpd %xmm0,%xmm0
andpd  0xdb4(%rip),%xmm0
ucomisd %xmm4,%xmm0
jbe    12e0 <estimate_ncf+0x1d0>
divsd  %xmm0,%xmm4
mulsd  %xmm4,%xmm2
mulsd  %xmm4,%xmm2
addsd  0xd4a(%rip),%xmm2
movapd %xmm0,%xmm4
movapd %xmm2,%xmm0
jmp    12ec <estimate_ncf+0x1dc>
divsd  %xmm4,%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm2,%xmm0
movapd 0xd7c(%rip),%xmm2
andpd  %xmm1,%xmm2
ucomisd %xmm4,%xmm2
jbe    131c <estimate_ncf+0x20c>
divsd  %xmm2,%xmm4
mulsd  %xmm4,%xmm0
mulsd  %xmm4,%xmm0
addsd  0xd0e(%rip),%xmm0
movapd %xmm2,%xmm4
movapd %xmm0,%xmm2
jmp    1328 <estimate_ncf+0x218>
divsd  %xmm4,%xmm2
mulsd  %xmm2,%xmm2
addsd  %xmm0,%xmm2
unpckhpd %xmm1,%xmm1
andpd  0xd3c(%rip),%xmm1
ucomisd %xmm4,%xmm1
jbe    1358 <estimate_ncf+0x248>
divsd  %xmm1,%xmm4
mulsd  %xmm4,%xmm2
mulsd  %xmm4,%xmm2
addsd  0xcd2(%rip),%xmm2
movapd %xmm1,%xmm4
movapd %xmm2,%xmm1
jmp    1364 <estimate_ncf+0x254>
divsd  %xmm4,%xmm1
mulsd  %xmm1,%xmm1
addsd  %xmm2,%xmm1
xorpd  %xmm0,%xmm0
ucomisd %xmm0,%xmm1
jb     1377 <estimate_ncf+0x267>
xorps  %xmm0,%xmm0
sqrtsd %xmm1,%xmm0
jmp    1398 <estimate_ncf+0x288>
movapd %xmm1,%xmm0
movapd %xmm15,0x10(%rsp)
movapd %xmm4,(%rsp)
call   1030 <sqrt@plt>
movapd (%rsp),%xmm4
movapd 0x10(%rsp),%xmm15
mulsd  %xmm0,%xmm4
unpcklpd %xmm4,%xmm4
movupd (%rbx),%xmm2
movupd 0x10(%rbx),%xmm3
divpd  %xmm4,%xmm2
movupd %xmm2,(%rbx)
divpd  %xmm4,%xmm3
movupd %xmm3,0x10(%rbx)
movapd %xmm2,%xmm1
unpckhpd %xmm2,%xmm1
movapd %xmm1,%xmm11
mulsd  %xmm1,%xmm11
movapd %xmm2,%xmm13
mulsd  %xmm2,%xmm13
movapd %xmm13,%xmm14
addsd  %xmm11,%xmm14
movapd 0xc97(%rip),%xmm8
movapd %xmm3,%xmm9
xorpd  %xmm8,%xmm9
mulsd  %xmm3,%xmm9
addsd  %xmm9,%xmm14
movapd %xmm3,%xmm5
unpckhpd %xmm3,%xmm5
movapd %xmm5,%xmm6
xorpd  %xmm8,%xmm6
mulsd  %xmm5,%xmm6
addsd  %xmm6,%xmm14
movapd %xmm1,%xmm10
movapd %xmm5,%xmm4
mulsd  %xmm2,%xmm4
movapd %xmm2,%xmm12
mulsd  %xmm1,%xmm12
mulsd  %xmm3,%xmm1
subsd  %xmm4,%xmm1
subsd  %xmm11,%xmm13
movapd %xmm3,%xmm7
movapd %xmm3,%xmm4
mulsd  %xmm3,%xmm4
addsd  %xmm13,%xmm4
addsd  %xmm6,%xmm4
movapd %xmm2,%xmm6
xorpd  %xmm8,%xmm6
shufpd $0x1,%xmm6,%xmm7
movapd %xmm2,%xmm0
mulsd  %xmm3,%xmm0
mulpd  %xmm2,%xmm7
shufpd $0x1,%xmm3,%xmm2
mulpd  %xmm3,%xmm2
mulsd  %xmm5,%xmm10
mulsd  %xmm5,%xmm3
addsd  %xmm12,%xmm3
movapd %xmm10,%xmm6
subsd  %xmm0,%xmm6
addsd  %xmm10,%xmm0
addpd  %xmm7,%xmm2
addsd  %xmm9,%xmm13
mulsd  %xmm5,%xmm5
addsd  %xmm13,%xmm5
xorpd  %xmm8,%xmm14
movsd  0xb7a(%rip),%xmm7
mulsd  %xmm7,%xmm0
unpcklpd %xmm0,%xmm14
mulsd  %xmm7,%xmm1
mulsd  %xmm7,%xmm6
mulsd  %xmm7,%xmm3
xorpd  %xmm8,%xmm5
unpcklpd %xmm5,%xmm6
xorpd  %xmm0,%xmm0
mulsd  %xmm0,%xmm1
addsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm4
mulpd  0xbac(%rip),%xmm2
subsd  %xmm4,%xmm1
mulsd  0xb40(%rip),%xmm3
addsd  %xmm1,%xmm3
xorpd  %xmm0,%xmm0
mulpd  %xmm0,%xmm14
addpd  %xmm0,%xmm14
mulpd  %xmm0,%xmm2
addpd  %xmm14,%xmm2
mulpd  0xb8d(%rip),%xmm6
addpd  %xmm2,%xmm6
movupd 0x8(%r14),%xmm0
movapd %xmm0,%xmm1
shufpd $0x1,%xmm0,%xmm1
movsd  (%r14),%xmm2
movapd %xmm6,%xmm4
mulpd  %xmm6,%xmm1
mulsd  %xmm0,%xmm6
movsd  %xmm2,%xmm0
shufpd $0x1,%xmm3,%xmm4
mulpd  %xmm0,%xmm4
subpd  %xmm4,%xmm1
mulsd  %xmm2,%xmm3
subsd  %xmm6,%xmm3
mulpd  0xae8(%rip),%xmm1
movapd %xmm15,%xmm0
unpcklpd %xmm15,%xmm0
shufpd $0x1,%xmm1,%xmm1
mulpd  %xmm0,%xmm1
movupd %xmm1,(%r15)
mulsd  0xa88(%rip),%xmm3
mulsd  %xmm15,%xmm3
movsd  %xmm3,0x10(%r15)
add    $0x20,%rsp
pop    %rbx
pop    %r14
pop    %r15
ret

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

LLVM IR (-O2):
define void @estimate_ncf(double* nocapture %0, double* nocapture %1, double* nocapture %2, double* nocapture %3, double %4, double %5) {
%7 = load double, double* %2
%8 = load double, double* %1
%9 = fadd double %7, %8
%10 = getelementptr inbounds double, double* %2, i64 1
%11 = getelementptr inbounds double, double* %1, i64 1
%12 = bitcast double* %10 to <2 x double>*
%13 = load <2 x double>, <2 x double>* %12
%14 = bitcast double* %11 to <2 x double>*
%15 = load <2 x double>, <2 x double>* %14
%16 = fadd <2 x double> %13, %15
%17 = fmul double %9, 5.000000e-01
%18 = fmul <2 x double> %16, <double 5.000000e-01, double 5.000000e-01>
%19 = fmul double %9, -5.000000e-01
%20 = fmul <2 x double> %16, <double -5.000000e-01, double -5.000000e-01>
%21 = shufflevector <2 x double> %20, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%22 = bitcast double* %0 to <2 x double>*
%23 = load <2 x double>, <2 x double>* %22
%24 = getelementptr inbounds double, double* %0, i64 2
%25 = bitcast double* %24 to <2 x double>*
%26 = load <2 x double>, <2 x double>* %25
%27 = insertelement <2 x double> %23, double %17, i64 1
%28 = shufflevector <2 x double> <double 0.000000e+00, double poison>, <2 x double> %23, <2 x i32> <i32 0, i32 2>
%29 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %27, <2 x double> %28, <2 x double> zeroinitializer)
%30 = insertelement <2 x double> %23, double %19, i64 0
%31 = shufflevector <2 x double> <double poison, double 0.000000e+00>, <2 x double> %23, <2 x i32> <i32 3, i32 1>
%32 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %30, <2 x double> %31, <2 x double> %29)
%33 = fmul <2 x double> %16, <double -5.000000e-01, double 5.000000e-01>
%34 = shufflevector <2 x double> %26, <2 x double> poison, <2 x i32> zeroinitializer
%35 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %33, <2 x double> %34, <2 x double> %32)
%36 = shufflevector <2 x double> %26, <2 x double> undef, <2 x i32> <i32 1, i32 1>
%37 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %21, <2 x double> %36, <2 x double> %35)
%38 = shufflevector <2 x double> %23, <2 x double> poison, <2 x i32> zeroinitializer
%39 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %18, <2 x double> %38, <2 x double> zeroinitializer)
%40 = shufflevector <2 x double> %20, <2 x double> %18, <2 x i32> <i32 1, i32 2>
%41 = shufflevector <2 x double> %23, <2 x double> undef, <2 x i32> <i32 1, i32 1>
%42 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %40, <2 x double> %41, <2 x double> %39)
%43 = insertelement <2 x double> %26, double %19, i64 1
%44 = shufflevector <2 x double> <double 0.000000e+00, double poison>, <2 x double> %26, <2 x i32> <i32 0, i32 2>
%45 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %43, <2 x double> %44, <2 x double> %42)
%46 = insertelement <2 x double> %26, double %17, i64 0
%47 = shufflevector <2 x double> <double poison, double 0.000000e+00>, <2 x double> %26, <2 x i32> <i32 3, i32 1>
%48 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %46, <2 x double> %47, <2 x double> %45)
%49 = insertelement <2 x double> poison, double %5, i64 0
%50 = shufflevector <2 x double> %49, <2 x double> poison, <2 x i32> zeroinitializer
%51 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %37, <2 x double> %50, <2 x double> %23)
%52 = bitcast double* %0 to <2 x double>*
store <2 x double> %51, <2 x double>* %52
%53 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %48, <2 x double> %50, <2 x double> %26)
%54 = bitcast double* %24 to <2 x double>*
store <2 x double> %53, <2 x double>* %54
%55 = extractelement <2 x double> %51, i64 0
%56 = tail call double @llvm.fabs.f64(double %55)
%57 = fcmp ogt double %56, 0x10000000000000
br i1 %57, label %58, label %62
58: ; preds = %6
%59 = fdiv double 0x10000000000000, %56
%60 = fmul double %59, 0.000000e+00
%61 = tail call double @llvm.fmuladd.f64(double %60, double %59, double 1.000000e+00)
br label %65
62: ; preds = %6
%63 = fmul double %56, 0x7FD0000000000000
%64 = tail call double @llvm.fmuladd.f64(double %63, double %63, double 0.000000e+00)
br label %65
65: ; preds = %58, %62
%66 = phi double [ %61, %58 ], [ %64, %62 ]
%67 = phi double [ %56, %58 ], [ 0x10000000000000, %62 ]
%68 = extractelement <2 x double> %51, i64 1
%69 = tail call double @llvm.fabs.f64(double %68)
%70 = fcmp ogt double %69, %67
br i1 %70, label %74, label %71
71: ; preds = %65
%72 = fdiv double %69, %67
%73 = tail call double @llvm.fmuladd.f64(double %72, double %72, double %66)
br label %78
74: ; preds = %65
%75 = fdiv double %67, %69
%76 = fmul double %66, %75
%77 = tail call double @llvm.fmuladd.f64(double %76, double %75, double 1.000000e+00)
br label %78
78: ; preds = %74, %71
%79 = phi double [ %77, %74 ], [ %73, %71 ]
%80 = phi double [ %69, %74 ], [ %67, %71 ]
%81 = extractelement <2 x double> %53, i64 0
%82 = tail call double @llvm.fabs.f64(double %81)
%83 = fcmp ogt double %82, %80
br i1 %83, label %87, label %84
84: ; preds = %78
%85 = fdiv double %82, %80
%86 = tail call double @llvm.fmuladd.f64(double %85, double %85, double %79)
br label %91
87: ; preds = %78
%88 = fdiv double %80, %82
%89 = fmul double %79, %88
%90 = tail call double @llvm.fmuladd.f64(double %89, double %88, double 1.000000e+00)
br label %91
91: ; preds = %87, %84
%92 = phi double [ %90, %87 ], [ %86, %84 ]
%93 = phi double [ %82, %87 ], [ %80, %84 ]
%94 = extractelement <2 x double> %53, i64 1
%95 = tail call double @llvm.fabs.f64(double %94)
%96 = fcmp ogt double %95, %93
br i1 %96, label %100, label %97
97: ; preds = %91
%98 = fdiv double %95, %93
%99 = tail call double @llvm.fmuladd.f64(double %98, double %98, double %92)
br label %104
100: ; preds = %91
%101 = fdiv double %93, %95
%102 = fmul double %92, %101
%103 = tail call double @llvm.fmuladd.f64(double %102, double %101, double 1.000000e+00)
br label %104
104: ; preds = %100, %97
%105 = phi double [ %103, %100 ], [ %99, %97 ]
%106 = phi double [ %95, %100 ], [ %93, %97 ]
%107 = getelementptr inbounds double, double* %1, i64 2
%108 = tail call double @sqrt(double %105)
%109 = fmul double %106, %108
%110 = bitcast double* %0 to <2 x double>*
%111 = load <2 x double>, <2 x double>* %110
%112 = insertelement <2 x double> poison, double %109, i64 0
%113 = shufflevector <2 x double> %112, <2 x double> poison, <2 x i32> zeroinitializer
%114 = fdiv <2 x double> %111, %113
%115 = bitcast double* %0 to <2 x double>*
store <2 x double> %114, <2 x double>* %115
%116 = bitcast double* %24 to <2 x double>*
%117 = load <2 x double>, <2 x double>* %116
%118 = fdiv <2 x double> %117, %113
%119 = bitcast double* %24 to <2 x double>*
store <2 x double> %118, <2 x double>* %119
%120 = extractelement <2 x double> %114, i64 1
%121 = fmul double %120, %120
%122 = extractelement <2 x double> %114, i64 0
%123 = tail call double @llvm.fmuladd.f64(double %122, double %122, double %121)
%124 = extractelement <2 x double> %118, i64 0
%125 = fneg double %124
%126 = tail call double @llvm.fmuladd.f64(double %125, double %124, double %123)
%127 = extractelement <2 x double> %118, i64 1
%128 = fneg double %127
%129 = tail call double @llvm.fmuladd.f64(double %128, double %127, double %126)
%130 = fneg double %122
%131 = fmul double %124, %130
%132 = tail call double @llvm.fmuladd.f64(double %120, double %127, double %131)
%133 = fmul double %127, %130
%134 = tail call double @llvm.fmuladd.f64(double %120, double %124, double %133)
%135 = fneg double %120
%136 = fmul double %120, %135
%137 = tail call double @llvm.fmuladd.f64(double %122, double %122, double %136)
%138 = tail call double @llvm.fmuladd.f64(double %124, double %124, double %137)
%139 = tail call double @llvm.fmuladd.f64(double %128, double %127, double %138)
%140 = fmul double %122, %120
%141 = tail call double @llvm.fmuladd.f64(double %124, double %127, double %140)
%142 = fmul <2 x double> %114, %118
%143 = extractelement <2 x double> %142, i64 0
%144 = tail call double @llvm.fmuladd.f64(double %120, double %127, double %143)
%145 = insertelement <2 x double> poison, double %127, i64 0
%146 = insertelement <2 x double> %145, double %130, i64 1
%147 = fmul <2 x double> %114, %146
%148 = shufflevector <2 x double> %114, <2 x double> %118, <2 x i32> <i32 1, i32 2>
%149 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %148, <2 x double> %118, <2 x double> %147)
%150 = tail call double @llvm.fmuladd.f64(double %125, double %124, double %137)
%151 = tail call double @llvm.fmuladd.f64(double %127, double %127, double %150)
%152 = fneg double %129
%153 = fmul double %134, -2.000000e+00
%154 = fmul double %144, -2.000000e+00
%155 = fneg double %139
%156 = fmul <2 x double> %149, <double -2.000000e+00, double -2.000000e+00>
%157 = fmul double %132, -2.000000e+00
%158 = fmul double %141, -2.000000e+00
%159 = fneg double %151
%160 = tail call double @llvm.fmuladd.f64(double %153, double 0.000000e+00, double 0.000000e+00)
%161 = tail call double @llvm.fmuladd.f64(double %155, double 0.000000e+00, double %160)
%162 = tail call double @llvm.fmuladd.f64(double %158, double -9.810000e+00, double %161)
%163 = insertelement <2 x double> poison, double %152, i64 0
%164 = insertelement <2 x double> %163, double %154, i64 1
%165 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %164, <2 x double> zeroinitializer, <2 x double> zeroinitializer)
%166 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %156, <2 x double> zeroinitializer, <2 x double> %165)
%167 = insertelement <2 x double> poison, double %157, i64 0
%168 = insertelement <2 x double> %167, double %159, i64 1
%169 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %168, <2 x double> <double -9.810000e+00, double -9.810000e+00>, <2 x double> %166)
%170 = getelementptr inbounds double, double* %3, i64 1
%171 = bitcast double* %170 to <2 x double>*
%172 = load <2 x double>, <2 x double>* %171
%173 = shufflevector <2 x double> %172, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%174 = load double, double* %3
%175 = insertelement <2 x double> %172, double %174, i64 0
%176 = fneg <2 x double> %175
%177 = extractelement <2 x double> %169, i64 1
%178 = insertelement <2 x double> poison, double %177, i64 0
%179 = insertelement <2 x double> %178, double %162, i64 1
%180 = fmul <2 x double> %179, %176
%181 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %173, <2 x double> %169, <2 x double> %180)
%182 = extractelement <2 x double> %172, i64 0
%183 = fneg double %182
%184 = extractelement <2 x double> %169, i64 0
%185 = fmul double %184, %183
%186 = tail call double @llvm.fmuladd.f64(double %174, double %162, double %185)
%187 = fmul <2 x double> %181, <double 5.000000e-01, double 5.000000e-01>
%188 = insertelement <2 x double> poison, double %4, i64 0
%189 = shufflevector <2 x double> %188, <2 x double> poison, <2 x i32> zeroinitializer
%190 = fmul <2 x double> %187, %189
%191 = shufflevector <2 x double> %190, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%192 = bitcast double* %1 to <2 x double>*
store <2 x double> %191, <2 x double>* %192
%193 = fmul double %186, 5.000000e-01
%194 = fmul double %193, %4
store double %194, double* %107
ret void
}