float inspherefast(pa, pb, pc, pd, pe)
float *pa;
float *pb;
float *pc;
float *pd;
float *pe;
{
  float aex, bex, cex, dex;
  float aey, bey, cey, dey;
  float aez, bez, cez, dez;
  float alift, blift, clift, dlift;
  float ab, bc, cd, da, ac, bd;
  float abc, bcd, cda, dab;
  aex = pa[0] - pe[0];
  bex = pb[0] - pe[0];
  cex = pc[0] - pe[0];
  dex = pd[0] - pe[0];
  aey = pa[1] - pe[1];
  bey = pb[1] - pe[1];
  cey = pc[1] - pe[1];
  dey = pd[1] - pe[1];
  aez = pa[2] - pe[2];
  bez = pb[2] - pe[2];
  cez = pc[2] - pe[2];
  dez = pd[2] - pe[2];
  ab = aex * bey - bex * aey;
  bc = bex * cey - cex * bey;
  cd = cex * dey - dex * cey;
  da = dex * aey - aex * dey;
  ac = aex * cey - cex * aey;
  bd = bex * dey - dex * bey;
  abc = aez * bc - bez * ac + cez * ab;
  bcd = bez * cd - cez * bd + dez * bc;
  cda = cez * da + dez * ac + aez * cd;
  dab = dez * ab + aez * bd + bez * da;
  alift = aex * aex + aey * aey + aez * aez;
  blift = bex * bex + bey * bey + bez * bez;
  clift = cex * cex + cey * cey + cez * cez;
  dlift = dex * dex + dey * dey + dez * dez;
  return (dlift * abc - clift * dab) + (blift * cda - alift * bcd);
}


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

x86 assembly (clang, -O2):
<inspherefast>:
movss  (%rdx),%xmm1
movss  0x4(%rdx),%xmm2
movss  0x8(%rdx),%xmm13
movss  (%rdi),%xmm12
unpcklps %xmm1,%xmm12
movss  0x4(%rdi),%xmm9
unpcklps %xmm2,%xmm9
movss  0x8(%rdi),%xmm1
unpcklps %xmm1,%xmm13
movss  (%r8),%xmm1
movss  0x4(%r8),%xmm3
movss  0x8(%r8),%xmm4
shufps $0x0,%xmm1,%xmm1
subps  %xmm1,%xmm12
movss  (%rsi),%xmm2
movss  0x4(%rsi),%xmm5
movss  0x8(%rsi),%xmm6
movss  (%rcx),%xmm11
unpcklps %xmm2,%xmm11
movss  0x4(%rcx),%xmm8
unpcklps %xmm5,%xmm8
movss  0x8(%rcx),%xmm2
unpcklps %xmm6,%xmm2
subps  %xmm1,%xmm11
shufps $0x0,%xmm3,%xmm3
subps  %xmm3,%xmm9
subps  %xmm3,%xmm8
shufps $0x0,%xmm4,%xmm4
subps  %xmm4,%xmm13
subps  %xmm4,%xmm2
movaps %xmm11,%xmm14
shufps $0x55,%xmm11,%xmm14
movaps %xmm11,%xmm3
shufps $0xe1,%xmm11,%xmm3
movaps 0xe5f(%rip),%xmm5
movaps %xmm9,%xmm4
mulps  %xmm3,%xmm4
xorps  %xmm5,%xmm3
movaps %xmm8,%xmm0
shufps $0xe1,%xmm8,%xmm0
movaps %xmm12,%xmm1
mulps  %xmm0,%xmm1
subps  %xmm4,%xmm1
movaps %xmm12,%xmm7
shufps $0xe1,%xmm12,%xmm7
mulps  %xmm7,%xmm0
xorps  %xmm5,%xmm7
movaps %xmm9,%xmm4
shufps $0x55,%xmm9,%xmm4
movaps %xmm11,%xmm6
mulps  %xmm9,%xmm6
shufps $0xe1,%xmm6,%xmm6
subps  %xmm0,%xmm6
mulss  %xmm9,%xmm7
mulss  %xmm12,%xmm4
addss  %xmm7,%xmm4
mulps  %xmm8,%xmm3
shufps $0x55,%xmm3,%xmm3
mulss  %xmm8,%xmm14
addss  %xmm3,%xmm14
movaps %xmm2,%xmm0
shufps $0x55,%xmm2,%xmm0
xorps  %xmm5,%xmm0
xorps  %xmm13,%xmm5
shufps $0x0,%xmm4,%xmm4
unpcklps %xmm2,%xmm0
mulps  %xmm4,%xmm0
movaps %xmm13,%xmm3
shufps $0x51,%xmm13,%xmm3
mulps  %xmm6,%xmm3
addps  %xmm0,%xmm3
movaps %xmm13,%xmm10
mulps  %xmm1,%xmm10
addps  %xmm3,%xmm10
shufps $0x0,%xmm14,%xmm14
shufps $0xd4,%xmm13,%xmm5
shufps $0x52,%xmm13,%xmm5
mulps  %xmm14,%xmm5
mulps  %xmm2,%xmm1
addps  %xmm5,%xmm1
mulps  %xmm2,%xmm6
shufps $0xe1,%xmm6,%xmm6
addps  %xmm1,%xmm6
mulps  %xmm9,%xmm9
mulps  %xmm12,%xmm12
addps  %xmm9,%xmm12
shufps $0xe1,%xmm12,%xmm12
mulps  %xmm13,%xmm13
addps  %xmm12,%xmm13
mulps  %xmm6,%xmm13
mulps  %xmm8,%xmm8
mulps  %xmm11,%xmm11
addps  %xmm8,%xmm11
mulps  %xmm2,%xmm2
addps  %xmm11,%xmm2
mulps  %xmm10,%xmm2
subps  %xmm13,%xmm2
movaps %xmm2,%xmm0
shufps $0x55,%xmm2,%xmm0
addss  %xmm2,%xmm0
ret

LLVM IR (-O0):
define float @inspherefast(float* %0, float* %1, float* %2, float* %3, float* %4) {
%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
store float* %0, float** %6
store float* %1, float** %7
store float* %2, float** %8
store float* %3, float** %9
store float* %4, float** %10
%37 = load float*, float** %6
%38 = getelementptr inbounds float, float* %37, i64 0
%39 = load float, float* %38
%40 = load float*, float** %10
%41 = getelementptr inbounds float, float* %40, i64 0
%42 = load float, float* %41
%43 = fsub float %39, %42
store float %43, float* %11
%44 = load float*, float** %7
%45 = getelementptr inbounds float, float* %44, i64 0
%46 = load float, float* %45
%47 = load float*, float** %10
%48 = getelementptr inbounds float, float* %47, i64 0
%49 = load float, float* %48
%50 = fsub float %46, %49
store float %50, float* %12
%51 = load float*, float** %8
%52 = getelementptr inbounds float, float* %51, i64 0
%53 = load float, float* %52
%54 = load float*, float** %10
%55 = getelementptr inbounds float, float* %54, i64 0
%56 = load float, float* %55
%57 = fsub float %53, %56
store float %57, float* %13
%58 = load float*, float** %9
%59 = getelementptr inbounds float, float* %58, i64 0
%60 = load float, float* %59
%61 = load float*, float** %10
%62 = getelementptr inbounds float, float* %61, i64 0
%63 = load float, float* %62
%64 = fsub float %60, %63
store float %64, float* %14
%65 = load float*, float** %6
%66 = getelementptr inbounds float, float* %65, i64 1
%67 = load float, float* %66
%68 = load float*, float** %10
%69 = getelementptr inbounds float, float* %68, i64 1
%70 = load float, float* %69
%71 = fsub float %67, %70
store float %71, float* %15
%72 = load float*, float** %7
%73 = getelementptr inbounds float, float* %72, i64 1
%74 = load float, float* %73
%75 = load float*, float** %10
%76 = getelementptr inbounds float, float* %75, i64 1
%77 = load float, float* %76
%78 = fsub float %74, %77
store float %78, float* %16
%79 = load float*, float** %8
%80 = getelementptr inbounds float, float* %79, i64 1
%81 = load float, float* %80
%82 = load float*, float** %10
%83 = getelementptr inbounds float, float* %82, i64 1
%84 = load float, float* %83
%85 = fsub float %81, %84
store float %85, float* %17
%86 = load float*, float** %9
%87 = getelementptr inbounds float, float* %86, i64 1
%88 = load float, float* %87
%89 = load float*, float** %10
%90 = getelementptr inbounds float, float* %89, i64 1
%91 = load float, float* %90
%92 = fsub float %88, %91
store float %92, float* %18
%93 = load float*, float** %6
%94 = getelementptr inbounds float, float* %93, i64 2
%95 = load float, float* %94
%96 = load float*, float** %10
%97 = getelementptr inbounds float, float* %96, i64 2
%98 = load float, float* %97
%99 = fsub float %95, %98
store float %99, float* %19
%100 = load float*, float** %7
%101 = getelementptr inbounds float, float* %100, i64 2
%102 = load float, float* %101
%103 = load float*, float** %10
%104 = getelementptr inbounds float, float* %103, i64 2
%105 = load float, float* %104
%106 = fsub float %102, %105
store float %106, float* %20
%107 = load float*, float** %8
%108 = getelementptr inbounds float, float* %107, i64 2
%109 = load float, float* %108
%110 = load float*, float** %10
%111 = getelementptr inbounds float, float* %110, i64 2
%112 = load float, float* %111
%113 = fsub float %109, %112
store float %113, float* %21
%114 = load float*, float** %9
%115 = getelementptr inbounds float, float* %114, i64 2
%116 = load float, float* %115
%117 = load float*, float** %10
%118 = getelementptr inbounds float, float* %117, i64 2
%119 = load float, float* %118
%120 = fsub float %116, %119
store float %120, float* %22
%121 = load float, float* %11
%122 = load float, float* %16
%123 = load float, float* %12
%124 = load float, float* %15
%125 = fmul float %123, %124
%126 = fneg float %125
%127 = call float @llvm.fmuladd.f32(float %121, float %122, float %126)
store float %127, float* %27
%128 = load float, float* %12
%129 = load float, float* %17
%130 = load float, float* %13
%131 = load float, float* %16
%132 = fmul float %130, %131
%133 = fneg float %132
%134 = call float @llvm.fmuladd.f32(float %128, float %129, float %133)
store float %134, float* %28
%135 = load float, float* %13
%136 = load float, float* %18
%137 = load float, float* %14
%138 = load float, float* %17
%139 = fmul float %137, %138
%140 = fneg float %139
%141 = call float @llvm.fmuladd.f32(float %135, float %136, float %140)
store float %141, float* %29
%142 = load float, float* %14
%143 = load float, float* %15
%144 = load float, float* %11
%145 = load float, float* %18
%146 = fmul float %144, %145
%147 = fneg float %146
%148 = call float @llvm.fmuladd.f32(float %142, float %143, float %147)
store float %148, float* %30
%149 = load float, float* %11
%150 = load float, float* %17
%151 = load float, float* %13
%152 = load float, float* %15
%153 = fmul float %151, %152
%154 = fneg float %153
%155 = call float @llvm.fmuladd.f32(float %149, float %150, float %154)
store float %155, float* %31
%156 = load float, float* %12
%157 = load float, float* %18
%158 = load float, float* %14
%159 = load float, float* %16
%160 = fmul float %158, %159
%161 = fneg float %160
%162 = call float @llvm.fmuladd.f32(float %156, float %157, float %161)
store float %162, float* %32
%163 = load float, float* %19
%164 = load float, float* %28
%165 = load float, float* %20
%166 = load float, float* %31
%167 = fmul float %165, %166
%168 = fneg float %167
%169 = call float @llvm.fmuladd.f32(float %163, float %164, float %168)
%170 = load float, float* %21
%171 = load float, float* %27
%172 = call float @llvm.fmuladd.f32(float %170, float %171, float %169)
store float %172, float* %33
%173 = load float, float* %20
%174 = load float, float* %29
%175 = load float, float* %21
%176 = load float, float* %32
%177 = fmul float %175, %176
%178 = fneg float %177
%179 = call float @llvm.fmuladd.f32(float %173, float %174, float %178)
%180 = load float, float* %22
%181 = load float, float* %28
%182 = call float @llvm.fmuladd.f32(float %180, float %181, float %179)
store float %182, float* %34
%183 = load float, float* %21
%184 = load float, float* %30
%185 = load float, float* %22
%186 = load float, float* %31
%187 = fmul float %185, %186
%188 = call float @llvm.fmuladd.f32(float %183, float %184, float %187)
%189 = load float, float* %19
%190 = load float, float* %29
%191 = call float @llvm.fmuladd.f32(float %189, float %190, float %188)
store float %191, float* %35
%192 = load float, float* %22
%193 = load float, float* %27
%194 = load float, float* %19
%195 = load float, float* %32
%196 = fmul float %194, %195
%197 = call float @llvm.fmuladd.f32(float %192, float %193, float %196)
%198 = load float, float* %20
%199 = load float, float* %30
%200 = call float @llvm.fmuladd.f32(float %198, float %199, float %197)
store float %200, float* %36
%201 = load float, float* %11
%202 = load float, float* %11
%203 = load float, float* %15
%204 = load float, float* %15
%205 = fmul float %203, %204
%206 = call float @llvm.fmuladd.f32(float %201, float %202, float %205)
%207 = load float, float* %19
%208 = load float, float* %19
%209 = call float @llvm.fmuladd.f32(float %207, float %208, float %206)
store float %209, float* %23
%210 = load float, float* %12
%211 = load float, float* %12
%212 = load float, float* %16
%213 = load float, float* %16
%214 = fmul float %212, %213
%215 = call float @llvm.fmuladd.f32(float %210, float %211, float %214)
%216 = load float, float* %20
%217 = load float, float* %20
%218 = call float @llvm.fmuladd.f32(float %216, float %217, float %215)
store float %218, float* %24
%219 = load float, float* %13
%220 = load float, float* %13
%221 = load float, float* %17
%222 = load float, float* %17
%223 = fmul float %221, %222
%224 = call float @llvm.fmuladd.f32(float %219, float %220, float %223)
%225 = load float, float* %21
%226 = load float, float* %21
%227 = call float @llvm.fmuladd.f32(float %225, float %226, float %224)
store float %227, float* %25
%228 = load float, float* %14
%229 = load float, float* %14
%230 = load float, float* %18
%231 = load float, float* %18
%232 = fmul float %230, %231
%233 = call float @llvm.fmuladd.f32(float %228, float %229, float %232)
%234 = load float, float* %22
%235 = load float, float* %22
%236 = call float @llvm.fmuladd.f32(float %234, float %235, float %233)
store float %236, float* %26
%237 = load float, float* %26
%238 = load float, float* %33
%239 = load float, float* %25
%240 = load float, float* %36
%241 = fmul float %239, %240
%242 = fneg float %241
%243 = call float @llvm.fmuladd.f32(float %237, float %238, float %242)
%244 = load float, float* %24
%245 = load float, float* %35
%246 = load float, float* %23
%247 = load float, float* %34
%248 = fmul float %246, %247
%249 = fneg float %248
%250 = call float @llvm.fmuladd.f32(float %244, float %245, float %249)
%251 = fadd float %243, %250
ret float %251
}

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