int planeBoxOverlap(float normal[3], float d, float maxbox[3]) {
  int q;
  float vmin[3], vmax[3];
  for (q = 0; q <= 2; q++) {
    if (normal[q] > 0.0f) {
      vmin[q] = -maxbox[q];
      vmax[q] = maxbox[q];
    } else {
      vmin[q] = maxbox[q];
      vmax[q] = -maxbox[q];
    }
  }
  if ((normal[0] * vmin[0] + normal[1] * vmin[1] + normal[2] * vmin[2]) + d >
      0.0f)
    return 0;
  if ((normal[0] * vmax[0] + normal[1] * vmax[1] + normal[2] * vmax[2]) + d >=
      0.0f)
    return 1;
  return 0;
}


x86 assembly (clang, -O0):
<planeBoxOverlap>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x10(%rbp)
movss  %xmm0,-0x14(%rbp)
mov    %rsi,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
cmpl   $0x2,-0x24(%rbp)
jg     11c9 <planeBoxOverlap+0xc9>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    117b <planeBoxOverlap+0x7b>
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movslq -0x24(%rbp),%rax
movss  %xmm0,-0x30(%rbp,%rax,4)
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movslq -0x24(%rbp),%rax
movss  %xmm0,-0x3c(%rbp,%rax,4)
jmp    11b6 <planeBoxOverlap+0xb6>
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movslq -0x24(%rbp),%rax
movss  %xmm0,-0x30(%rbp,%rax,4)
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movslq -0x24(%rbp),%rax
movss  %xmm0,-0x3c(%rbp,%rax,4)
jmp    11bb <planeBoxOverlap+0xbb>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1118 <planeBoxOverlap+0x18>
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm1
movss  -0x30(%rbp),%xmm2
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
mulss  -0x2c(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  -0x28(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
addss  -0x14(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    121f <planeBoxOverlap+0x11f>
movl   $0x0,-0x4(%rbp)
jmp    127c <planeBoxOverlap+0x17c>
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm1
movss  -0x3c(%rbp),%xmm2
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
mulss  -0x38(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  -0x34(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
addss  -0x14(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     1275 <planeBoxOverlap+0x175>
movl   $0x1,-0x4(%rbp)
jmp    127c <planeBoxOverlap+0x17c>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<planeBoxOverlap>:
movss  %xmm0,-0x4(%rsp)
movss  (%rdi),%xmm13
movss  0x4(%rdi),%xmm0
movss  (%rsi),%xmm9
movss  0x4(%rsi),%xmm11
movaps 0xede(%rip),%xmm3
movaps %xmm9,%xmm10
xorps  %xmm3,%xmm10
xorps  %xmm6,%xmm6
cmpltss %xmm13,%xmm6
movaps %xmm6,%xmm1
andps  %xmm10,%xmm1
movaps %xmm6,%xmm4
andnps %xmm9,%xmm4
orps   %xmm1,%xmm4
movaps %xmm11,%xmm14
xorps  %xmm3,%xmm14
xorps  %xmm7,%xmm7
cmpltss %xmm0,%xmm7
movaps %xmm7,%xmm1
andps  %xmm14,%xmm1
movaps %xmm7,%xmm2
andnps %xmm11,%xmm2
orps   %xmm1,%xmm2
movss  0x8(%rdi),%xmm1
movss  0x8(%rsi),%xmm15
xorps  %xmm15,%xmm3
xorps  %xmm8,%xmm8
cmpltss %xmm1,%xmm8
movaps %xmm8,%xmm5
andps  %xmm3,%xmm5
movaps %xmm8,%xmm12
andnps %xmm15,%xmm12
orps   %xmm5,%xmm12
mulss  %xmm0,%xmm2
mulss  %xmm13,%xmm4
addss  %xmm2,%xmm4
mulss  %xmm1,%xmm12
addss  %xmm4,%xmm12
movss  -0x4(%rsp),%xmm4
xorps  %xmm2,%xmm2
addss  %xmm4,%xmm12
xor    %eax,%eax
ucomiss %xmm2,%xmm12
ja     1206 <planeBoxOverlap+0x106>
andps  %xmm8,%xmm15
andnps %xmm3,%xmm8
orps   %xmm15,%xmm8
andps  %xmm7,%xmm11
andnps %xmm14,%xmm7
orps   %xmm11,%xmm7
andps  %xmm6,%xmm9
andnps %xmm10,%xmm6
orps   %xmm9,%xmm6
mulss  %xmm7,%xmm0
mulss  %xmm6,%xmm13
addss  %xmm0,%xmm13
mulss  %xmm8,%xmm1
addss  %xmm13,%xmm1
addss  %xmm4,%xmm1
xor    %eax,%eax
ucomiss %xmm2,%xmm1
setae  %al
ret

LLVM IR (-O0):
define i32 @planeBoxOverlap(float* %0, float %1, float* %2) {
%4 = alloca i32
%5 = alloca float*
%6 = alloca float
%7 = alloca float*
%8 = alloca i32
%9 = alloca [3 x float]
%10 = alloca [3 x float]
store float* %0, float** %5
store float %1, float* %6
store float* %2, float** %7
store i32 0, i32* %8
br label %11
11: ; preds = %58, %3
%12 = load i32, i32* %8
%13 = icmp sle i32 %12, 2
br i1 %13, label %14, label %61
14: ; preds = %11
%15 = load float*, float** %5
%16 = load i32, i32* %8
%17 = sext i32 %16 to i64
%18 = getelementptr inbounds float, float* %15, i64 %17
%19 = load float, float* %18
%20 = fcmp ogt float %19, 0.000000e+00
br i1 %20, label %21, label %39
21: ; preds = %14
%22 = load float*, float** %7
%23 = load i32, i32* %8
%24 = sext i32 %23 to i64
%25 = getelementptr inbounds float, float* %22, i64 %24
%26 = load float, float* %25
%27 = fneg float %26
%28 = load i32, i32* %8
%29 = sext i32 %28 to i64
%30 = getelementptr inbounds [3 x float], [3 x float]* %9, i64 0, i64 %29
store float %27, float* %30
%31 = load float*, float** %7
%32 = load i32, i32* %8
%33 = sext i32 %32 to i64
%34 = getelementptr inbounds float, float* %31, i64 %33
%35 = load float, float* %34
%36 = load i32, i32* %8
%37 = sext i32 %36 to i64
%38 = getelementptr inbounds [3 x float], [3 x float]* %10, i64 0, i64 %37
store float %35, float* %38
br label %57
39: ; preds = %14
%40 = load float*, float** %7
%41 = load i32, i32* %8
%42 = sext i32 %41 to i64
%43 = getelementptr inbounds float, float* %40, i64 %42
%44 = load float, float* %43
%45 = load i32, i32* %8
%46 = sext i32 %45 to i64
%47 = getelementptr inbounds [3 x float], [3 x float]* %9, i64 0, i64 %46
store float %44, float* %47
%48 = load float*, float** %7
%49 = load i32, i32* %8
%50 = sext i32 %49 to i64
%51 = getelementptr inbounds float, float* %48, i64 %50
%52 = load float, float* %51
%53 = fneg float %52
%54 = load i32, i32* %8
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds [3 x float], [3 x float]* %10, i64 0, i64 %55
store float %53, float* %56
br label %57
57: ; preds = %39, %21
br label %58
58: ; preds = %57
%59 = load i32, i32* %8
%60 = add nsw i32 %59, 1
store i32 %60, i32* %8
br label %11
61: ; preds = %11
%62 = load float*, float** %5
%63 = getelementptr inbounds float, float* %62, i64 0
%64 = load float, float* %63
%65 = getelementptr inbounds [3 x float], [3 x float]* %9, i64 0, i64 0
%66 = load float, float* %65
%67 = load float*, float** %5
%68 = getelementptr inbounds float, float* %67, i64 1
%69 = load float, float* %68
%70 = getelementptr inbounds [3 x float], [3 x float]* %9, i64 0, i64 1
%71 = load float, float* %70
%72 = fmul float %69, %71
%73 = call float @llvm.fmuladd.f32(float %64, float %66, float %72)
%74 = load float*, float** %5
%75 = getelementptr inbounds float, float* %74, i64 2
%76 = load float, float* %75
%77 = getelementptr inbounds [3 x float], [3 x float]* %9, i64 0, i64 2
%78 = load float, float* %77
%79 = call float @llvm.fmuladd.f32(float %76, float %78, float %73)
%80 = load float, float* %6
%81 = fadd float %79, %80
%82 = fcmp ogt float %81, 0.000000e+00
br i1 %82, label %83, label %84
83: ; preds = %61
store i32 0, i32* %4
br label %108
84: ; preds = %61
%85 = load float*, float** %5
%86 = getelementptr inbounds float, float* %85, i64 0
%87 = load float, float* %86
%88 = getelementptr inbounds [3 x float], [3 x float]* %10, i64 0, i64 0
%89 = load float, float* %88
%90 = load float*, float** %5
%91 = getelementptr inbounds float, float* %90, i64 1
%92 = load float, float* %91
%93 = getelementptr inbounds [3 x float], [3 x float]* %10, i64 0, i64 1
%94 = load float, float* %93
%95 = fmul float %92, %94
%96 = call float @llvm.fmuladd.f32(float %87, float %89, float %95)
%97 = load float*, float** %5
%98 = getelementptr inbounds float, float* %97, i64 2
%99 = load float, float* %98
%100 = getelementptr inbounds [3 x float], [3 x float]* %10, i64 0, i64 2
%101 = load float, float* %100
%102 = call float @llvm.fmuladd.f32(float %99, float %101, float %96)
%103 = load float, float* %6
%104 = fadd float %102, %103
%105 = fcmp oge float %104, 0.000000e+00
br i1 %105, label %106, label %107
106: ; preds = %84
store i32 1, i32* %4
br label %108
107: ; preds = %84
store i32 0, i32* %4
br label %108
108: ; preds = %107, %106, %83
%109 = load i32, i32* %4
ret i32 %109
}

LLVM IR (-O2):
define i32 @planeBoxOverlap(float* nocapture %0, float %1, float* nocapture %2) {
%4 = load float, float* %0
%5 = fcmp ogt float %4, 0.000000e+00
%6 = load float, float* %2
%7 = fneg float %6
%8 = select i1 %5, float %7, float %6
%9 = getelementptr inbounds float, float* %0, i64 1
%10 = load float, float* %9
%11 = fcmp ogt float %10, 0.000000e+00
%12 = getelementptr inbounds float, float* %2, i64 1
%13 = load float, float* %12
%14 = fneg float %13
%15 = select i1 %11, float %14, float %13
%16 = getelementptr inbounds float, float* %0, i64 2
%17 = load float, float* %16
%18 = fcmp ogt float %17, 0.000000e+00
%19 = getelementptr inbounds float, float* %2, i64 2
%20 = load float, float* %19
%21 = fneg float %20
%22 = select i1 %18, float %21, float %20
%23 = fmul float %10, %15
%24 = tail call float @llvm.fmuladd.f32(float %4, float %8, float %23)
%25 = tail call float @llvm.fmuladd.f32(float %17, float %22, float %24)
%26 = fadd float %25, %1
%27 = fcmp ogt float %26, 0.000000e+00
br i1 %27, label %38, label %28
28: ; preds = %3
%29 = select i1 %18, float %20, float %21
%30 = select i1 %11, float %13, float %14
%31 = select i1 %5, float %6, float %7
%32 = fmul float %10, %30
%33 = tail call float @llvm.fmuladd.f32(float %4, float %31, float %32)
%34 = tail call float @llvm.fmuladd.f32(float %17, float %29, float %33)
%35 = fadd float %34, %1
%36 = fcmp oge float %35, 0.000000e+00
%37 = zext i1 %36 to i32
br label %38
38: ; preds = %28, %3
%39 = phi i32 [ 0, %3 ], [ %37, %28 ]
ret i32 %39
}