int plane_test(const float *b, const float *v) {
  const float k00 = b[0] * v[0];
  const float k11 = b[1] * v[1];
  const float k22 = b[2] * v[2];
  const float k30 = b[3] * v[0];
  const float k41 = b[4] * v[1];
  const float k52 = b[5] * v[2];
  return (k00 + k11 + k22 + v[3] > 0 ? 1 : 0) +
         (k00 + k11 + k52 + v[3] > 0 ? 1 : 0) +
         (k00 + k41 + k22 + v[3] > 0 ? 1 : 0) +
         (k00 + k41 + k52 + v[3] > 0 ? 1 : 0) +
         (k30 + k11 + k22 + v[3] > 0 ? 1 : 0) +
         (k30 + k11 + k52 + v[3] > 0 ? 1 : 0) +
         (k30 + k41 + k22 + v[3] > 0 ? 1 : 0) +
         (k30 + k41 + k52 + v[3] > 0 ? 1 : 0);
}


x86 assembly (clang, -O0):
<plane_test>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  (%rax),%xmm0
movss  %xmm0,-0x14(%rbp)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x4(%rax),%xmm0
movss  %xmm0,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x8(%rax),%xmm0
movss  %xmm0,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  (%rax),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movss  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x4(%rax),%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x8(%rax),%xmm0
movss  %xmm0,-0x28(%rbp)
movss  -0x14(%rbp),%xmm0
addss  -0x18(%rbp),%xmm0
addss  -0x1c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
addss  0xc(%rax),%xmm0
xorps  %xmm1,%xmm1
xor    %eax,%eax
mov    $0x1,%ecx
ucomiss %xmm1,%xmm0
cmova  %ecx,%eax
movss  -0x14(%rbp),%xmm0
addss  -0x18(%rbp),%xmm0
addss  -0x28(%rbp),%xmm0
mov    -0x10(%rbp),%rcx
addss  0xc(%rcx),%xmm0
xorps  %xmm1,%xmm1
xor    %ecx,%ecx
mov    $0x1,%edx
ucomiss %xmm1,%xmm0
cmova  %edx,%ecx
add    %ecx,%eax
movss  -0x14(%rbp),%xmm0
addss  -0x24(%rbp),%xmm0
addss  -0x1c(%rbp),%xmm0
mov    -0x10(%rbp),%rcx
addss  0xc(%rcx),%xmm0
xorps  %xmm1,%xmm1
xor    %ecx,%ecx
mov    $0x1,%edx
ucomiss %xmm1,%xmm0
cmova  %edx,%ecx
add    %ecx,%eax
movss  -0x14(%rbp),%xmm0
addss  -0x24(%rbp),%xmm0
addss  -0x28(%rbp),%xmm0
mov    -0x10(%rbp),%rcx
addss  0xc(%rcx),%xmm0
xorps  %xmm1,%xmm1
xor    %ecx,%ecx
mov    $0x1,%edx
ucomiss %xmm1,%xmm0
cmova  %edx,%ecx
add    %ecx,%eax
movss  -0x20(%rbp),%xmm0
addss  -0x18(%rbp),%xmm0
addss  -0x1c(%rbp),%xmm0
mov    -0x10(%rbp),%rcx
addss  0xc(%rcx),%xmm0
xorps  %xmm1,%xmm1
xor    %ecx,%ecx
mov    $0x1,%edx
ucomiss %xmm1,%xmm0
cmova  %edx,%ecx
add    %ecx,%eax
movss  -0x20(%rbp),%xmm0
addss  -0x18(%rbp),%xmm0
addss  -0x28(%rbp),%xmm0
mov    -0x10(%rbp),%rcx
addss  0xc(%rcx),%xmm0
xorps  %xmm1,%xmm1
xor    %ecx,%ecx
mov    $0x1,%edx
ucomiss %xmm1,%xmm0
cmova  %edx,%ecx
add    %ecx,%eax
movss  -0x20(%rbp),%xmm0
addss  -0x24(%rbp),%xmm0
addss  -0x1c(%rbp),%xmm0
mov    -0x10(%rbp),%rcx
addss  0xc(%rcx),%xmm0
xorps  %xmm1,%xmm1
xor    %ecx,%ecx
mov    $0x1,%edx
ucomiss %xmm1,%xmm0
cmova  %edx,%ecx
add    %ecx,%eax
movss  -0x20(%rbp),%xmm0
addss  -0x24(%rbp),%xmm0
addss  -0x28(%rbp),%xmm0
mov    -0x10(%rbp),%rcx
addss  0xc(%rcx),%xmm0
xorps  %xmm1,%xmm1
xor    %ecx,%ecx
mov    $0x1,%edx
ucomiss %xmm1,%xmm0
cmova  %edx,%ecx
add    %ecx,%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<plane_test>:
movsd  (%rsi),%xmm0
movsd  (%rdi),%xmm2
mulps  %xmm0,%xmm2
movsd  0xc(%rdi),%xmm1
mulps  %xmm0,%xmm1
movaps %xmm2,%xmm0
shufps $0x55,%xmm2,%xmm0
addss  %xmm2,%xmm0
movss  0x8(%rdi),%xmm3
shufps $0xd4,%xmm2,%xmm3
movss  0x8(%rsi),%xmm4
movlhps %xmm4,%xmm2
shufps $0x22,%xmm2,%xmm3
movaps %xmm1,%xmm2
shufps $0x55,%xmm1,%xmm2
movaps %xmm1,%xmm5
addss  %xmm1,%xmm2
unpcklps %xmm4,%xmm1
movss  0x14(%rdi),%xmm4
shufps $0xc5,%xmm4,%xmm5
shufps $0x24,%xmm5,%xmm1
movaps %xmm3,%xmm4
addps  %xmm1,%xmm4
mulps  %xmm3,%xmm1
movaps %xmm4,%xmm3
shufps $0x9c,%xmm1,%xmm3
shufps $0x78,%xmm3,%xmm3
shufps $0xd4,%xmm1,%xmm0
shufps $0x93,%xmm1,%xmm4
shufps $0x82,%xmm0,%xmm0
addps  %xmm3,%xmm0
shufps $0xa,%xmm2,%xmm1
addps  %xmm4,%xmm1
movss  0xc(%rsi),%xmm2
shufps $0x0,%xmm2,%xmm2
addps  %xmm2,%xmm0
addps  %xmm1,%xmm2
xorps  %xmm1,%xmm1
xorps  %xmm3,%xmm3
cmpltps %xmm2,%xmm3
cmpltps %xmm0,%xmm1
packssdw %xmm3,%xmm1
packsswb %xmm1,%xmm1
pmovmskb %xmm1,%eax
mov    %eax,%ecx
shr    %cl
and    $0x55,%cl
sub    %cl,%al
mov    %eax,%ecx
and    $0x33,%cl
shr    $0x2,%al
and    $0x33,%al
add    %cl,%al
mov    %eax,%ecx
shr    $0x4,%cl
add    %al,%cl
and    $0xf,%cl
movzbl %cl,%eax
ret

LLVM IR (-O0):
define i32 @plane_test(float* %0, float* %1) {
%3 = alloca float*
%4 = alloca float*
%5 = alloca float
%6 = alloca float
%7 = alloca float
%8 = alloca float
%9 = alloca float
%10 = alloca float
store float* %0, float** %3
store float* %1, float** %4
%11 = load float*, float** %3
%12 = getelementptr inbounds float, float* %11, i64 0
%13 = load float, float* %12
%14 = load float*, float** %4
%15 = getelementptr inbounds float, float* %14, i64 0
%16 = load float, float* %15
%17 = fmul float %13, %16
store float %17, float* %5
%18 = load float*, float** %3
%19 = getelementptr inbounds float, float* %18, i64 1
%20 = load float, float* %19
%21 = load float*, float** %4
%22 = getelementptr inbounds float, float* %21, i64 1
%23 = load float, float* %22
%24 = fmul float %20, %23
store float %24, float* %6
%25 = load float*, float** %3
%26 = getelementptr inbounds float, float* %25, i64 2
%27 = load float, float* %26
%28 = load float*, float** %4
%29 = getelementptr inbounds float, float* %28, i64 2
%30 = load float, float* %29
%31 = fmul float %27, %30
store float %31, float* %7
%32 = load float*, float** %3
%33 = getelementptr inbounds float, float* %32, i64 3
%34 = load float, float* %33
%35 = load float*, float** %4
%36 = getelementptr inbounds float, float* %35, i64 0
%37 = load float, float* %36
%38 = fmul float %34, %37
store float %38, float* %8
%39 = load float*, float** %3
%40 = getelementptr inbounds float, float* %39, i64 4
%41 = load float, float* %40
%42 = load float*, float** %4
%43 = getelementptr inbounds float, float* %42, i64 1
%44 = load float, float* %43
%45 = fmul float %41, %44
store float %45, float* %9
%46 = load float*, float** %3
%47 = getelementptr inbounds float, float* %46, i64 5
%48 = load float, float* %47
%49 = load float*, float** %4
%50 = getelementptr inbounds float, float* %49, i64 2
%51 = load float, float* %50
%52 = fmul float %48, %51
store float %52, float* %10
%53 = load float, float* %5
%54 = load float, float* %6
%55 = fadd float %53, %54
%56 = load float, float* %7
%57 = fadd float %55, %56
%58 = load float*, float** %4
%59 = getelementptr inbounds float, float* %58, i64 3
%60 = load float, float* %59
%61 = fadd float %57, %60
%62 = fcmp ogt float %61, 0.000000e+00
%63 = zext i1 %62 to i64
%64 = select i1 %62, i32 1, i32 0
%65 = load float, float* %5
%66 = load float, float* %6
%67 = fadd float %65, %66
%68 = load float, float* %10
%69 = fadd float %67, %68
%70 = load float*, float** %4
%71 = getelementptr inbounds float, float* %70, i64 3
%72 = load float, float* %71
%73 = fadd float %69, %72
%74 = fcmp ogt float %73, 0.000000e+00
%75 = zext i1 %74 to i64
%76 = select i1 %74, i32 1, i32 0
%77 = add nsw i32 %64, %76
%78 = load float, float* %5
%79 = load float, float* %9
%80 = fadd float %78, %79
%81 = load float, float* %7
%82 = fadd float %80, %81
%83 = load float*, float** %4
%84 = getelementptr inbounds float, float* %83, i64 3
%85 = load float, float* %84
%86 = fadd float %82, %85
%87 = fcmp ogt float %86, 0.000000e+00
%88 = zext i1 %87 to i64
%89 = select i1 %87, i32 1, i32 0
%90 = add nsw i32 %77, %89
%91 = load float, float* %5
%92 = load float, float* %9
%93 = fadd float %91, %92
%94 = load float, float* %10
%95 = fadd float %93, %94
%96 = load float*, float** %4
%97 = getelementptr inbounds float, float* %96, i64 3
%98 = load float, float* %97
%99 = fadd float %95, %98
%100 = fcmp ogt float %99, 0.000000e+00
%101 = zext i1 %100 to i64
%102 = select i1 %100, i32 1, i32 0
%103 = add nsw i32 %90, %102
%104 = load float, float* %8
%105 = load float, float* %6
%106 = fadd float %104, %105
%107 = load float, float* %7
%108 = fadd float %106, %107
%109 = load float*, float** %4
%110 = getelementptr inbounds float, float* %109, i64 3
%111 = load float, float* %110
%112 = fadd float %108, %111
%113 = fcmp ogt float %112, 0.000000e+00
%114 = zext i1 %113 to i64
%115 = select i1 %113, i32 1, i32 0
%116 = add nsw i32 %103, %115
%117 = load float, float* %8
%118 = load float, float* %6
%119 = fadd float %117, %118
%120 = load float, float* %10
%121 = fadd float %119, %120
%122 = load float*, float** %4
%123 = getelementptr inbounds float, float* %122, i64 3
%124 = load float, float* %123
%125 = fadd float %121, %124
%126 = fcmp ogt float %125, 0.000000e+00
%127 = zext i1 %126 to i64
%128 = select i1 %126, i32 1, i32 0
%129 = add nsw i32 %116, %128
%130 = load float, float* %8
%131 = load float, float* %9
%132 = fadd float %130, %131
%133 = load float, float* %7
%134 = fadd float %132, %133
%135 = load float*, float** %4
%136 = getelementptr inbounds float, float* %135, i64 3
%137 = load float, float* %136
%138 = fadd float %134, %137
%139 = fcmp ogt float %138, 0.000000e+00
%140 = zext i1 %139 to i64
%141 = select i1 %139, i32 1, i32 0
%142 = add nsw i32 %129, %141
%143 = load float, float* %8
%144 = load float, float* %9
%145 = fadd float %143, %144
%146 = load float, float* %10
%147 = fadd float %145, %146
%148 = load float*, float** %4
%149 = getelementptr inbounds float, float* %148, i64 3
%150 = load float, float* %149
%151 = fadd float %147, %150
%152 = fcmp ogt float %151, 0.000000e+00
%153 = zext i1 %152 to i64
%154 = select i1 %152, i32 1, i32 0
%155 = add nsw i32 %142, %154
ret i32 %155
}

LLVM IR (-O2):
define i32 @plane_test(float* nocapture %0, float* nocapture %1) {
%3 = bitcast float* %1 to <2 x float>*
%4 = load <2 x float>, <2 x float>* %3
%5 = bitcast float* %0 to <2 x float>*
%6 = load <2 x float>, <2 x float>* %5
%7 = fmul <2 x float> %6, %4
%8 = shufflevector <2 x float> %7, <2 x float> poison, <4 x i32> <i32 0, i32 undef, i32 undef, i32 undef>
%9 = getelementptr inbounds float, float* %0, i64 2
%10 = load float, float* %9
%11 = getelementptr inbounds float, float* %1, i64 2
%12 = load float, float* %11
%13 = getelementptr inbounds float, float* %0, i64 3
%14 = bitcast float* %13 to <2 x float>*
%15 = load <2 x float>, <2 x float>* %14
%16 = fmul <2 x float> %4, %15
%17 = shufflevector <2 x float> %16, <2 x float> poison, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
%18 = getelementptr inbounds float, float* %0, i64 5
%19 = load float, float* %18
%20 = extractelement <2 x float> %7, i64 0
%21 = extractelement <2 x float> %7, i64 1
%22 = fadd float %20, %21
%23 = getelementptr inbounds float, float* %1, i64 3
%24 = load float, float* %23
%25 = insertelement <4 x float> poison, float %21, i64 0
%26 = insertelement <4 x float> %25, float %10, i64 1
%27 = insertelement <4 x float> %26, float %12, i64 2
%28 = shufflevector <4 x float> %27, <4 x float> %8, <4 x i32> <i32 0, i32 1, i32 2, i32 4>
%29 = extractelement <2 x float> %16, i64 0
%30 = insertelement <4 x float> %17, float %12, i64 1
%31 = insertelement <4 x float> %30, float %19, i64 2
%32 = extractelement <2 x float> %16, i64 1
%33 = shufflevector <4 x float> %31, <4 x float> %17, <4 x i32> <i32 0, i32 1, i32 2, i32 5>
%34 = fadd <4 x float> %28, %33
%35 = shufflevector <4 x float> %34, <4 x float> poison, <8 x i32> <i32 0, i32 undef, i32 undef, i32 3, i32 undef, i32 undef, i32 undef, i32 undef>
%36 = fmul <4 x float> %28, %33
%37 = shufflevector <4 x float> %36, <4 x float> poison, <8 x i32> <i32 undef, i32 undef, i32 2, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
%38 = shufflevector <4 x float> %34, <4 x float> %36, <4 x i32> <i32 0, i32 5, i32 6, i32 3>
%39 = fadd float %29, %32
%40 = extractelement <4 x float> %36, i64 1
%41 = insertelement <8 x float> poison, float %40, i64 0
%42 = insertelement <8 x float> %41, float %22, i64 1
%43 = shufflevector <8 x float> %42, <8 x float> %35, <8 x i32> <i32 0, i32 1, i32 11, i32 8, i32 undef, i32 undef, i32 undef, i32 undef>
%44 = shufflevector <8 x float> %43, <8 x float> %37, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 10, i32 undef, i32 undef, i32 undef>
%45 = shufflevector <8 x float> %44, <8 x float> poison, <8 x i32> <i32 0, i32 1, i32 1, i32 0, i32 2, i32 3, i32 0, i32 4>
%46 = shufflevector <4 x float> %38, <4 x float> poison, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 undef, i32 undef, i32 undef, i32 undef>
%47 = insertelement <8 x float> %46, float %39, i64 4
%48 = shufflevector <8 x float> %47, <8 x float> poison, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 2, i32 2, i32 4, i32 4>
%49 = fadd <8 x float> %45, %48
%50 = insertelement <8 x float> poison, float %24, i64 0
%51 = shufflevector <8 x float> %50, <8 x float> poison, <8 x i32> zeroinitializer
%52 = fadd <8 x float> %49, %51
%53 = fcmp ogt <8 x float> %52, zeroinitializer
%54 = bitcast <8 x i1> %53 to i8
%55 = call i8 @llvm.ctpop.i8(i8 %54)
%56 = zext i8 %55 to i32
ret i32 %56
}