void CubicParam(float *x, float *f, float *param) {
  float x11, x12, x13, x21, x22, x23, x31, x32, x33, x41, x42, x43;
  float m21, m22, m31, m32, m41, m42;
  float d2, d3, d4, p2, p3, p4, q3, q4, r3, r4, s3, s4, qs34, qr34;
  float a, b, c, d;
  x11 = x[0];
  x12 = x11 * x11;
  x13 = x11 * x12;
  x21 = x[1];
  x22 = x21 * x21;
  x23 = x21 * x22;
  x31 = x[2];
  x32 = x31 * x31;
  x33 = x31 * x32;
  x41 = x[3];
  x42 = x41 * x41;
  x43 = x41 * x42;
  m21 = (x13 * x21 - x11 * x23);
  m22 = (x13 * x22 - x12 * x23);
  m31 = (x13 * x31 - x11 * x33);
  m32 = (x13 * x32 - x12 * x33);
  m41 = (x13 * x41 - x11 * x43);
  m42 = (x13 * x42 - x12 * x43);
  d2 = (x13 - x23);
  d3 = (x13 - x33);
  d4 = (x13 - x43);
  p2 = (x23 * f[0] - x13 * f[1]);
  p3 = (x33 * f[0] - x13 * f[2]);
  p4 = (x43 * f[0] - x13 * f[3]);
  q3 = (m22 * m31 - m21 * m32);
  q4 = (m22 * m41 - m21 * m42);
  r3 = (d3 * m22 - d2 * m32);
  r4 = (d4 * m22 - d2 * m42);
  s3 = (m22 * p3 - m32 * p2);
  s4 = (m22 * p4 - m42 * p2);
  qs34 = (q3 * s4 - q4 * s3);
  qr34 = (q3 * r4 - q4 * r3);
  a = (m22 * qs34 * q3 - m22 * qs34 * r3 * x11 + m22 * qr34 * s3 * x11 +
       p2 * qr34 * q3 * x12 - d2 * qs34 * q3 * x12 + m21 * qs34 * r3 * x12 -
       m21 * qr34 * s3 * x12 + m22 * qr34 * q3 * f[0]) /
      (m22 * qr34 * q3 * x13);
  b = (d2 * qs34 * q3 - m21 * qs34 * r3 + m21 * qr34 * s3 - p2 * qr34 * q3) /
      (m22 * qr34 * q3);
  c = (qs34 * r3 - qr34 * s3) / (qr34 * q3);
  d = -qs34 / qr34;
  param[0] = a;
  param[1] = b;
  param[2] = c;
  param[3] = d;
}


x86 assembly (clang, -O0):
<CubicParam>:
push   %rbp
mov    %rsp,%rbp
sub    $0x28,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x1c(%rbp)
movss  -0x1c(%rbp),%xmm0
mulss  -0x1c(%rbp),%xmm0
movss  %xmm0,-0x20(%rbp)
movss  -0x1c(%rbp),%xmm0
mulss  -0x20(%rbp),%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x28(%rbp)
movss  -0x28(%rbp),%xmm0
mulss  -0x28(%rbp),%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x28(%rbp),%xmm0
mulss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x34(%rbp),%xmm0
mulss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x34(%rbp),%xmm0
mulss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x8(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x40(%rbp),%xmm0
mulss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x40(%rbp),%xmm0
mulss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x24(%rbp),%xmm0
movss  -0x28(%rbp),%xmm2
movss  -0x1c(%rbp),%xmm1
mulss  -0x30(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x24(%rbp),%xmm0
movss  -0x2c(%rbp),%xmm2
movss  -0x20(%rbp),%xmm1
mulss  -0x30(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x24(%rbp),%xmm0
movss  -0x34(%rbp),%xmm2
movss  -0x1c(%rbp),%xmm1
mulss  -0x3c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x24(%rbp),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x20(%rbp),%xmm1
mulss  -0x3c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x24(%rbp),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x1c(%rbp),%xmm1
mulss  -0x48(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x24(%rbp),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x20(%rbp),%xmm1
mulss  -0x48(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x24(%rbp),%xmm0
subss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x24(%rbp),%xmm0
subss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x24(%rbp),%xmm0
subss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x30(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x24(%rbp),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x4(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x3c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x24(%rbp),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x8(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x24(%rbp),%xmm1
mov    -0x10(%rbp),%rax
mulss  0xc(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x50(%rbp),%xmm0
movss  -0x54(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  -0x58(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x50(%rbp),%xmm0
movss  -0x5c(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  -0x60(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x68(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  -0x58(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x6c(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  -0x60(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x50(%rbp),%xmm0
movss  -0x74(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  -0x70(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x50(%rbp),%xmm0
movss  -0x78(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  -0x70(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x90(%rbp)
ff
movss  -0x7c(%rbp),%xmm0
movss  -0x90(%rbp),%xmm2
ff
movss  -0x80(%rbp),%xmm1
mulss  -0x8c(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x94(%rbp)
ff
movss  -0x7c(%rbp),%xmm0
movss  -0x88(%rbp),%xmm2
ff
movss  -0x80(%rbp),%xmm1
mulss  -0x84(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x98(%rbp)
ff
movss  -0x50(%rbp),%xmm0
mulss  -0x94(%rbp),%xmm0
ff
movss  -0x7c(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  -0x94(%rbp),%xmm1
ff
mulss  -0x84(%rbp),%xmm1
ff
mulss  -0x1c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x50(%rbp),%xmm1
mulss  -0x98(%rbp),%xmm1
ff
mulss  -0x8c(%rbp),%xmm1
ff
movss  -0x1c(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x70(%rbp),%xmm0
mulss  -0x98(%rbp),%xmm0
ff
mulss  -0x7c(%rbp),%xmm0
movss  -0x20(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x64(%rbp),%xmm1
mulss  -0x94(%rbp),%xmm1
ff
mulss  -0x7c(%rbp),%xmm1
movss  -0x20(%rbp),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x4c(%rbp),%xmm0
mulss  -0x94(%rbp),%xmm0
ff
mulss  -0x84(%rbp),%xmm0
ff
movss  -0x20(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x4c(%rbp),%xmm1
mulss  -0x98(%rbp),%xmm1
ff
mulss  -0x8c(%rbp),%xmm1
ff
movss  -0x20(%rbp),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x50(%rbp),%xmm0
mulss  -0x98(%rbp),%xmm0
ff
mulss  -0x7c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x50(%rbp),%xmm1
mulss  -0x98(%rbp),%xmm1
ff
mulss  -0x7c(%rbp),%xmm1
mulss  -0x24(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
movss  -0x64(%rbp),%xmm0
mulss  -0x94(%rbp),%xmm0
ff
movss  -0x7c(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  -0x94(%rbp),%xmm1
ff
mulss  -0x84(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x4c(%rbp),%xmm1
mulss  -0x98(%rbp),%xmm1
ff
movss  -0x8c(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x70(%rbp),%xmm0
mulss  -0x98(%rbp),%xmm0
ff
movss  -0x7c(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x50(%rbp),%xmm1
mulss  -0x98(%rbp),%xmm1
ff
mulss  -0x7c(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
movss  -0x94(%rbp),%xmm0
ff
movss  -0x84(%rbp),%xmm2
ff
movss  -0x98(%rbp),%xmm1
ff
mulss  -0x8c(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x98(%rbp),%xmm1
ff
mulss  -0x7c(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
movss  -0x94(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
divss  -0x98(%rbp),%xmm0
ff
movss  %xmm0,-0xa8(%rbp)
ff
movss  -0x9c(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0xa0(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0xa4(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0xa8(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movss  %xmm0,0xc(%rax)
add    $0x28,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<CubicParam>:
movss  (%rdi),%xmm0
movaps %xmm0,%xmm1
mulss  %xmm0,%xmm1
movaps %xmm0,%xmm12
movaps %xmm0,%xmm5
movaps %xmm0,-0x28(%rsp)
mulss  %xmm1,%xmm12
movaps %xmm1,%xmm0
movaps %xmm1,-0x18(%rsp)
movsd  0x4(%rdi),%xmm8
movaps %xmm8,%xmm7
mulps  %xmm8,%xmm7
movaps %xmm8,%xmm9
mulps  %xmm7,%xmm9
movss  0xc(%rdi),%xmm4
movaps %xmm4,%xmm2
mulss  %xmm4,%xmm2
movaps %xmm4,%xmm3
mulss  %xmm2,%xmm3
unpcklps %xmm5,%xmm0
movaps 0xea9(%rip),%xmm1
movaps %xmm9,%xmm13
mulps  %xmm0,%xmm13
xorps  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm11
movaps %xmm9,%xmm6
mulss  %xmm11,%xmm6
movaps %xmm12,%xmm10
mulss  %xmm8,%xmm10
addss  %xmm6,%xmm10
movaps %xmm12,%xmm6
shufps $0x0,%xmm12,%xmm6
shufps $0x1,%xmm7,%xmm8
shufps $0xe2,%xmm7,%xmm8
mulps  %xmm6,%xmm8
subps  %xmm13,%xmm8
movaps %xmm9,%xmm6
shufps $0x55,%xmm9,%xmm6
movaps %xmm6,%xmm13
mulss  %xmm0,%xmm13
shufps $0x55,%xmm7,%xmm7
mulss  %xmm12,%xmm7
addss  %xmm13,%xmm7
mulss  %xmm3,%xmm11
mulss  %xmm12,%xmm4
addss  %xmm11,%xmm4
mulss  %xmm3,%xmm0
mulss  %xmm12,%xmm2
addss  %xmm0,%xmm2
movaps %xmm12,%xmm11
subss  %xmm9,%xmm11
movaps %xmm12,%xmm14
subss  %xmm6,%xmm14
movss  (%rsi),%xmm13
movss  0x4(%rsi),%xmm0
mulss  %xmm12,%xmm0
mulss  %xmm13,%xmm9
subss  %xmm0,%xmm9
movss  0x8(%rsi),%xmm0
mulss  %xmm12,%xmm0
mulss  %xmm13,%xmm6
subss  %xmm0,%xmm6
movaps %xmm12,%xmm15
subss  %xmm3,%xmm15
movss  0xc(%rsi),%xmm0
mulss  %xmm12,%xmm0
mulss  %xmm13,%xmm3
subss  %xmm0,%xmm3
movaps %xmm11,%xmm0
unpcklps %xmm10,%xmm0
movaps %xmm9,%xmm5
mulss  %xmm7,%xmm5
shufps $0x0,%xmm7,%xmm7
mulps  %xmm0,%xmm7
xorps  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
mulss  %xmm2,%xmm1
mulss  %xmm8,%xmm4
addss  %xmm1,%xmm4
unpcklps %xmm8,%xmm14
mulps  %xmm8,%xmm14
subps  %xmm7,%xmm14
mulss  %xmm2,%xmm0
mulss  %xmm8,%xmm15
addss  %xmm0,%xmm15
mulss  %xmm8,%xmm6
subss  %xmm5,%xmm6
mulss  %xmm9,%xmm2
mulss  %xmm8,%xmm3
subss  %xmm2,%xmm3
movaps %xmm6,%xmm0
mulss  %xmm4,%xmm0
movaps %xmm14,%xmm1
shufps $0x55,%xmm14,%xmm1
mulss  %xmm1,%xmm3
subss  %xmm0,%xmm3
mulss  %xmm14,%xmm4
mulss  %xmm1,%xmm15
subss  %xmm4,%xmm15
mulss  %xmm15,%xmm9
movaps %xmm1,%xmm2
mulss  %xmm9,%xmm2
xorps  0xd37(%rip),%xmm9
movaps %xmm3,%xmm0
unpcklps %xmm9,%xmm0
movaps %xmm8,%xmm4
mulss  %xmm3,%xmm4
movaps %xmm10,%xmm5
mulss  %xmm3,%xmm5
mulss  %xmm14,%xmm5
mulps  %xmm14,%xmm0
mulss  %xmm4,%xmm14
movaps -0x28(%rsp),%xmm7
mulss  %xmm7,%xmm14
mulss  %xmm1,%xmm4
subss  %xmm14,%xmm4
mulss  %xmm15,%xmm8
mulss  %xmm15,%xmm10
mulss  %xmm6,%xmm10
movaps %xmm15,%xmm9
movaps 0xce4(%rip),%xmm14
xorps  %xmm14,%xmm9
mulss  %xmm6,%xmm9
mulss  %xmm8,%xmm6
mulss  %xmm7,%xmm6
addss  %xmm4,%xmm6
movaps -0x18(%rsp),%xmm7
mulss  %xmm7,%xmm2
addss  %xmm6,%xmm2
mulss  %xmm3,%xmm11
mulss  %xmm1,%xmm11
movaps %xmm11,%xmm4
mulss  %xmm7,%xmm4
subss  %xmm4,%xmm2
subss  %xmm5,%xmm11
mulss  %xmm7,%xmm5
addss  %xmm2,%xmm5
mulss  %xmm10,%xmm7
subss  %xmm7,%xmm5
unpcklps %xmm15,%xmm8
mulps  %xmm1,%xmm8
mulss  %xmm8,%xmm13
addss  %xmm5,%xmm13
addss  %xmm11,%xmm10
unpcklps %xmm10,%xmm9
addps  %xmm9,%xmm0
xorps  %xmm14,%xmm3
shufps $0x10,%xmm0,%xmm13
movlhps %xmm0,%xmm3
shufps $0x28,%xmm3,%xmm13
mulss  %xmm8,%xmm12
movlhps %xmm8,%xmm12
shufps $0xd4,%xmm8,%xmm15
shufps $0x28,%xmm15,%xmm12
divps  %xmm12,%xmm13
movups %xmm13,(%rdx)
ret

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

LLVM IR (-O2):
define void @CubicParam(float* nocapture %0, float* nocapture %1, float* nocapture writeonly %2) {
%4 = load float, float* %0
%5 = fmul float %4, %4
%6 = fmul float %4, %5
%7 = getelementptr inbounds float, float* %0, i64 1
%8 = bitcast float* %7 to <2 x float>*
%9 = load <2 x float>, <2 x float>* %8
%10 = fmul <2 x float> %9, %9
%11 = fmul <2 x float> %9, %10
%12 = getelementptr inbounds float, float* %0, i64 3
%13 = load float, float* %12
%14 = fmul float %13, %13
%15 = fmul float %13, %14
%16 = insertelement <2 x float> poison, float %5, i64 0
%17 = insertelement <2 x float> %16, float %4, i64 1
%18 = fneg <2 x float> %17
%19 = extractelement <2 x float> %11, i64 0
%20 = extractelement <2 x float> %18, i64 1
%21 = fmul float %19, %20
%22 = extractelement <2 x float> %9, i64 0
%23 = tail call float @llvm.fmuladd.f32(float %6, float %22, float %21)
%24 = fmul <2 x float> %11, %18
%25 = insertelement <2 x float> poison, float %6, i64 0
%26 = shufflevector <2 x float> %25, <2 x float> poison, <2 x i32> zeroinitializer
%27 = shufflevector <2 x float> %10, <2 x float> %9, <2 x i32> <i32 0, i32 3>
%28 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %26, <2 x float> %27, <2 x float> %24)
%29 = extractelement <2 x float> %11, i64 1
%30 = extractelement <2 x float> %18, i64 0
%31 = fmul float %29, %30
%32 = extractelement <2 x float> %10, i64 1
%33 = tail call float @llvm.fmuladd.f32(float %6, float %32, float %31)
%34 = fmul float %15, %20
%35 = tail call float @llvm.fmuladd.f32(float %6, float %13, float %34)
%36 = fmul float %15, %30
%37 = tail call float @llvm.fmuladd.f32(float %6, float %14, float %36)
%38 = fsub float %6, %19
%39 = fsub float %6, %29
%40 = fsub float %6, %15
%41 = load float, float* %1
%42 = getelementptr inbounds float, float* %1, i64 1
%43 = load float, float* %42
%44 = fneg float %6
%45 = fmul float %43, %44
%46 = tail call float @llvm.fmuladd.f32(float %19, float %41, float %45)
%47 = getelementptr inbounds float, float* %1, i64 2
%48 = load float, float* %47
%49 = fmul float %48, %44
%50 = tail call float @llvm.fmuladd.f32(float %29, float %41, float %49)
%51 = getelementptr inbounds float, float* %1, i64 3
%52 = load float, float* %51
%53 = fmul float %52, %44
%54 = tail call float @llvm.fmuladd.f32(float %15, float %41, float %53)
%55 = insertelement <2 x float> poison, float %38, i64 0
%56 = insertelement <2 x float> %55, float %23, i64 1
%57 = fneg <2 x float> %56
%58 = extractelement <2 x float> %57, i64 1
%59 = fmul float %37, %58
%60 = extractelement <2 x float> %28, i64 0
%61 = tail call float @llvm.fmuladd.f32(float %60, float %35, float %59)
%62 = insertelement <2 x float> poison, float %33, i64 0
%63 = shufflevector <2 x float> %62, <2 x float> poison, <2 x i32> zeroinitializer
%64 = fmul <2 x float> %63, %57
%65 = insertelement <2 x float> poison, float %39, i64 0
%66 = shufflevector <2 x float> %65, <2 x float> %28, <2 x i32> <i32 0, i32 2>
%67 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %66, <2 x float> %28, <2 x float> %64)
%68 = extractelement <2 x float> %57, i64 0
%69 = fmul float %37, %68
%70 = tail call float @llvm.fmuladd.f32(float %40, float %60, float %69)
%71 = fneg float %33
%72 = fmul float %46, %71
%73 = tail call float @llvm.fmuladd.f32(float %60, float %50, float %72)
%74 = fneg float %37
%75 = fmul float %46, %74
%76 = tail call float @llvm.fmuladd.f32(float %60, float %54, float %75)
%77 = fneg float %61
%78 = fmul float %73, %77
%79 = extractelement <2 x float> %67, i64 1
%80 = tail call float @llvm.fmuladd.f32(float %79, float %76, float %78)
%81 = extractelement <2 x float> %67, i64 0
%82 = fmul float %81, %77
%83 = tail call float @llvm.fmuladd.f32(float %79, float %70, float %82)
%84 = fmul float %60, %80
%85 = fneg float %84
%86 = fmul float %81, %85
%87 = fmul float %4, %86
%88 = tail call float @llvm.fmuladd.f32(float %84, float %79, float %87)
%89 = fmul float %60, %83
%90 = fmul float %73, %89
%91 = tail call float @llvm.fmuladd.f32(float %90, float %4, float %88)
%92 = fmul float %46, %83
%93 = fmul float %79, %92
%94 = tail call float @llvm.fmuladd.f32(float %93, float %5, float %91)
%95 = fmul float %38, %80
%96 = fneg float %95
%97 = fmul float %79, %96
%98 = tail call float @llvm.fmuladd.f32(float %97, float %5, float %94)
%99 = fmul float %23, %80
%100 = fmul float %81, %99
%101 = tail call float @llvm.fmuladd.f32(float %100, float %5, float %98)
%102 = fmul float %23, %83
%103 = fneg float %102
%104 = fmul float %73, %103
%105 = tail call float @llvm.fmuladd.f32(float %104, float %5, float %101)
%106 = shufflevector <2 x float> %67, <2 x float> undef, <2 x i32> <i32 1, i32 1>
%107 = insertelement <2 x float> poison, float %89, i64 0
%108 = insertelement <2 x float> %107, float %83, i64 1
%109 = fmul <2 x float> %106, %108
%110 = extractelement <2 x float> %109, i64 0
%111 = tail call float @llvm.fmuladd.f32(float %110, float %41, float %105)
%112 = fmul float %6, %110
%113 = fneg float %100
%114 = tail call float @llvm.fmuladd.f32(float %95, float %79, float %113)
%115 = tail call float @llvm.fmuladd.f32(float %102, float %73, float %114)
%116 = fneg float %92
%117 = fneg float %83
%118 = fmul float %73, %117
%119 = insertelement <2 x float> poison, float %80, i64 0
%120 = insertelement <2 x float> %119, float %116, i64 1
%121 = insertelement <2 x float> poison, float %118, i64 0
%122 = insertelement <2 x float> %121, float %115, i64 1
%123 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %120, <2 x float> %67, <2 x float> %122)
%124 = fneg float %80
%125 = insertelement <4 x float> poison, float %111, i64 0
%126 = shufflevector <2 x float> %123, <2 x float> poison, <4 x i32> <i32 1, i32 0, i32 undef, i32 undef>
%127 = shufflevector <4 x float> %125, <4 x float> %126, <4 x i32> <i32 0, i32 4, i32 5, i32 undef>
%128 = insertelement <4 x float> %127, float %124, i64 3
%129 = insertelement <4 x float> poison, float %112, i64 0
%130 = shufflevector <2 x float> %109, <2 x float> poison, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
%131 = shufflevector <4 x float> %129, <4 x float> %130, <4 x i32> <i32 0, i32 4, i32 5, i32 undef>
%132 = insertelement <4 x float> %131, float %83, i64 3
%133 = fdiv <4 x float> %128, %132
%134 = bitcast float* %2 to <4 x float>*
store <4 x float> %133, <4 x float>* %134
ret void
}