int TriangleDegenerate(float *v1, float *n1, float *v2, float *n2, float *v3,
                       float *n3) {
  float axis1[3];
  float axis2[3];
  float axis3[3];
  float norm[3];
  float dot[3];
  {
    (norm)[0] = (n1)[0] + (n2)[0];
    (norm)[1] = (n1)[1] + (n2)[1];
    (norm)[2] = (n1)[2] + (n2)[2];
  };
  {
    (norm)[0] = (n3)[0] + (norm)[0];
    (norm)[1] = (n3)[1] + (norm)[1];
    (norm)[2] = (n3)[2] + (norm)[2];
  };
  {
    (axis1)[0] = (v1)[0] - (v2)[0];
    (axis1)[1] = (v1)[1] - (v2)[1];
    (axis1)[2] = (v1)[2] - (v2)[2];
  };
  {
    (axis2)[0] = (v3)[0] - (v2)[0];
    (axis2)[1] = (v3)[1] - (v2)[1];
    (axis2)[2] = (v3)[2] - (v2)[2];
  };
  {
    (axis3)[0] = ((axis1)[1] * (axis2)[2]) - ((axis1)[2] * (axis2)[1]);
    (axis3)[1] = ((axis1)[2] * (axis2)[0]) - ((axis1)[0] * (axis2)[2]);
    (axis3)[2] = ((axis1)[0] * (axis2)[1]) - ((axis1)[1] * (axis2)[0]);
  };
  dot[0] = ((axis3)[0] * (n1)[0] + (axis3)[1] * (n1)[1] + (axis3)[2] * (n1)[2]);
  dot[1] = ((axis3)[0] * (n2)[0] + (axis3)[1] * (n2)[1] + (axis3)[2] * (n2)[2]);
  dot[2] = ((axis3)[0] * (n3)[0] + (axis3)[1] * (n3)[1] + (axis3)[2] * (n3)[2]);
  return (!(((dot[0] > 0.0F) && (dot[1] > 0.0F) && (dot[2] > 0.0F)) ||
            ((dot[0] < 0.0F) && (dot[1] < 0.0F) && (dot[2] < 0.0F))));
}


x86 assembly (clang, -O0):
<TriangleDegenerate>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x20(%rbp),%rax
addss  (%rax),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x20(%rbp),%rax
addss  0x4(%rax),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x20(%rbp),%rax
addss  0x8(%rax),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x30(%rbp),%rax
movss  (%rax),%xmm0
addss  -0x60(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x30(%rbp),%rax
movss  0x4(%rax),%xmm0
addss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x30(%rbp),%rax
movss  0x8(%rax),%xmm0
addss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x18(%rbp),%rax
subss  (%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x18(%rbp),%rax
subss  0x4(%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x18(%rbp),%rax
subss  0x8(%rax),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x18(%rbp),%rax
subss  (%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x28(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x18(%rbp),%rax
subss  0x4(%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x28(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x18(%rbp),%rax
subss  0x8(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x38(%rbp),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x34(%rbp),%xmm1
mulss  -0x44(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x34(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x3c(%rbp),%xmm1
mulss  -0x40(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x38(%rbp),%xmm1
mulss  -0x48(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x54(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x50(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x4(%rax),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x4c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x54(%rbp),%xmm1
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x50(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mulss  0x4(%rax),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x4c(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x54(%rbp),%xmm1
mov    -0x30(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x50(%rbp),%xmm0
mov    -0x30(%rbp),%rax
mulss  0x4(%rax),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x4c(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x6c(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    1399 <TriangleDegenerate+0x299>
movss  -0x68(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    1399 <TriangleDegenerate+0x299>
movss  -0x64(%rbp),%xmm0
mov    $0x1,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
mov    %al,-0x6d(%rbp)
ja     13d0 <TriangleDegenerate+0x2d0>
xor    %eax,%eax
xorps  %xmm0,%xmm0
ucomiss -0x6c(%rbp),%xmm0
mov    %al,-0x6e(%rbp)
jbe    13ca <TriangleDegenerate+0x2ca>
xor    %eax,%eax
xorps  %xmm0,%xmm0
ucomiss -0x68(%rbp),%xmm0
mov    %al,-0x6e(%rbp)
jbe    13ca <TriangleDegenerate+0x2ca>
xorps  %xmm0,%xmm0
ucomiss -0x64(%rbp),%xmm0
seta   %al
mov    %al,-0x6e(%rbp)
mov    -0x6e(%rbp),%al
mov    %al,-0x6d(%rbp)
mov    -0x6d(%rbp),%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<TriangleDegenerate>:
movss  (%rdi),%xmm2
movss  0x4(%rdi),%xmm3
movss  (%rdx),%xmm4
movss  0x4(%rdx),%xmm5
subss  %xmm4,%xmm2
subss  %xmm5,%xmm3
movss  0x8(%rdi),%xmm1
movss  0x8(%rdx),%xmm6
subss  %xmm6,%xmm1
movss  (%r8),%xmm7
movss  0x4(%r8),%xmm0
subss  %xmm4,%xmm7
subss  %xmm5,%xmm0
movss  0x8(%r8),%xmm4
subss  %xmm6,%xmm4
movaps %xmm0,%xmm5
mulss  %xmm1,%xmm5
mulss  %xmm7,%xmm1
mulss  %xmm3,%xmm7
mulss  %xmm4,%xmm3
subss  %xmm5,%xmm3
mulss  %xmm2,%xmm4
subss  %xmm4,%xmm1
mulss  %xmm2,%xmm0
subss  %xmm7,%xmm0
movss  0x4(%rsi),%xmm2
mulss  %xmm1,%xmm2
movss  (%rsi),%xmm4
mulss  %xmm3,%xmm4
addss  %xmm2,%xmm4
movss  0x8(%rsi),%xmm2
mulss  %xmm0,%xmm2
addss  %xmm4,%xmm2
movss  0x4(%rcx),%xmm4
mulss  %xmm1,%xmm4
movss  (%rcx),%xmm5
mulss  %xmm3,%xmm5
addss  %xmm4,%xmm5
movss  0x8(%rcx),%xmm4
mulss  %xmm0,%xmm4
mulss  0x4(%r9),%xmm1
mulss  (%r9),%xmm3
addss  %xmm5,%xmm4
addss  %xmm1,%xmm3
mulss  0x8(%r9),%xmm0
addss  %xmm3,%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm2
jbe    11e1 <TriangleDegenerate+0xe1>
ucomiss %xmm1,%xmm4
jbe    11e1 <TriangleDegenerate+0xe1>
xor    %eax,%eax
xorps  %xmm3,%xmm3
ucomiss %xmm3,%xmm0
jbe    11e1 <TriangleDegenerate+0xe1>
ret
ucomiss %xmm2,%xmm1
mov    $0x1,%eax
jbe    11e0 <TriangleDegenerate+0xe0>
xorps  %xmm1,%xmm1
ucomiss %xmm4,%xmm1
jbe    11e0 <TriangleDegenerate+0xe0>
xor    %eax,%eax
ucomiss %xmm0,%xmm1
setbe  %al
ret

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

LLVM IR (-O2):
define i32 @TriangleDegenerate(float* nocapture %0, float* nocapture %1, float* nocapture %2, float* nocapture %3, float* nocapture %4, float* nocapture %5) {
%7 = load float, float* %1
%8 = load float, float* %3
%9 = getelementptr inbounds float, float* %1, i64 1
%10 = load float, float* %9
%11 = getelementptr inbounds float, float* %3, i64 1
%12 = load float, float* %11
%13 = getelementptr inbounds float, float* %1, i64 2
%14 = load float, float* %13
%15 = getelementptr inbounds float, float* %3, i64 2
%16 = load float, float* %15
%17 = load float, float* %5
%18 = getelementptr inbounds float, float* %5, i64 1
%19 = load float, float* %18
%20 = getelementptr inbounds float, float* %5, i64 2
%21 = load float, float* %20
%22 = load float, float* %0
%23 = load float, float* %2
%24 = fsub float %22, %23
%25 = getelementptr inbounds float, float* %0, i64 1
%26 = load float, float* %25
%27 = getelementptr inbounds float, float* %2, i64 1
%28 = load float, float* %27
%29 = fsub float %26, %28
%30 = getelementptr inbounds float, float* %0, i64 2
%31 = load float, float* %30
%32 = getelementptr inbounds float, float* %2, i64 2
%33 = load float, float* %32
%34 = fsub float %31, %33
%35 = load float, float* %4
%36 = fsub float %35, %23
%37 = getelementptr inbounds float, float* %4, i64 1
%38 = load float, float* %37
%39 = fsub float %38, %28
%40 = getelementptr inbounds float, float* %4, i64 2
%41 = load float, float* %40
%42 = fsub float %41, %33
%43 = fneg float %34
%44 = fmul float %39, %43
%45 = tail call float @llvm.fmuladd.f32(float %29, float %42, float %44)
%46 = fneg float %24
%47 = fmul float %42, %46
%48 = tail call float @llvm.fmuladd.f32(float %34, float %36, float %47)
%49 = fneg float %29
%50 = fmul float %36, %49
%51 = tail call float @llvm.fmuladd.f32(float %24, float %39, float %50)
%52 = fmul float %10, %48
%53 = tail call float @llvm.fmuladd.f32(float %45, float %7, float %52)
%54 = tail call float @llvm.fmuladd.f32(float %51, float %14, float %53)
%55 = fmul float %12, %48
%56 = tail call float @llvm.fmuladd.f32(float %45, float %8, float %55)
%57 = tail call float @llvm.fmuladd.f32(float %51, float %16, float %56)
%58 = fmul float %19, %48
%59 = tail call float @llvm.fmuladd.f32(float %45, float %17, float %58)
%60 = tail call float @llvm.fmuladd.f32(float %51, float %21, float %59)
%61 = fcmp ogt float %54, 0.000000e+00
%62 = fcmp ogt float %57, 0.000000e+00
%63 = select i1 %61, i1 %62, i1 false
%64 = fcmp ogt float %60, 0.000000e+00
%65 = select i1 %63, i1 %64, i1 false
br i1 %65, label %73, label %66
66: ; preds = %6
%67 = fcmp olt float %54, 0.000000e+00
%68 = fcmp olt float %57, 0.000000e+00
%69 = select i1 %67, i1 %68, i1 false
br i1 %69, label %70, label %73
70: ; preds = %66
%71 = fcmp uge float %60, 0.000000e+00
%72 = zext i1 %71 to i32
br label %73
73: ; preds = %66, %70, %6
%74 = phi i32 [ 0, %6 ], [ 1, %66 ], [ %72, %70 ]
ret i32 %74
}