#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int tri_tri_overlap_test_2d(float *, float *, float *, float *, float *,
                            float *);
int coplanar_tri_tri3d(float p1[3], float q1[3], float r1[3], float p2[3],
                       float q2[3], float r2[3], float normal_1[3],
                       float normal_2[3]) {
  float P1[2], Q1[2], R1[2];
  float P2[2], Q2[2], R2[2];
  float n_x, n_y, n_z;
  n_x = ((normal_1[0] < 0) ? -normal_1[0] : normal_1[0]);
  n_y = ((normal_1[1] < 0) ? -normal_1[1] : normal_1[1]);
  n_z = ((normal_1[2] < 0) ? -normal_1[2] : normal_1[2]);
  if ((n_x > n_z) && (n_x >= n_y)) {
    P1[0] = q1[2];
    P1[1] = q1[1];
    Q1[0] = p1[2];
    Q1[1] = p1[1];
    R1[0] = r1[2];
    R1[1] = r1[1];
    P2[0] = q2[2];
    P2[1] = q2[1];
    Q2[0] = p2[2];
    Q2[1] = p2[1];
    R2[0] = r2[2];
    R2[1] = r2[1];
  } else if ((n_y > n_z) && (n_y >= n_x)) {
    P1[0] = q1[0];
    P1[1] = q1[2];
    Q1[0] = p1[0];
    Q1[1] = p1[2];
    R1[0] = r1[0];
    R1[1] = r1[2];
    P2[0] = q2[0];
    P2[1] = q2[2];
    Q2[0] = p2[0];
    Q2[1] = p2[2];
    R2[0] = r2[0];
    R2[1] = r2[2];
  } else {
    P1[0] = p1[0];
    P1[1] = p1[1];
    Q1[0] = q1[0];
    Q1[1] = q1[1];
    R1[0] = r1[0];
    R1[1] = r1[1];
    P2[0] = p2[0];
    P2[1] = p2[1];
    Q2[0] = q2[0];
    Q2[1] = q2[1];
    R2[0] = r2[0];
    R2[1] = r2[1];
  }
  return tri_tri_overlap_test_2d(P1, Q1, R1, P2, Q2, R2);
}


x86 assembly (clang, -O0):
<coplanar_tri_tri3d>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
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
xorps  %xmm0,%xmm0
ucomiss (%rax),%xmm0
jbe    116a <coplanar_tri_tri3d+0x5a>
mov    0x10(%rbp),%rax
movss  (%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x70(%rbp)
jmp    1177 <coplanar_tri_tri3d+0x67>
mov    0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x70(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
mov    0x10(%rbp),%rax
xorps  %xmm0,%xmm0
ucomiss 0x4(%rax),%xmm0
jbe    11b2 <coplanar_tri_tri3d+0xa2>
mov    0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x74(%rbp)
jmp    11c0 <coplanar_tri_tri3d+0xb0>
mov    0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x74(%rbp),%xmm0
movss  %xmm0,-0x68(%rbp)
mov    0x10(%rbp),%rax
xorps  %xmm0,%xmm0
ucomiss 0x8(%rax),%xmm0
jbe    11fb <coplanar_tri_tri3d+0xeb>
mov    0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x78(%rbp)
jmp    1209 <coplanar_tri_tri3d+0xf9>
mov    0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x78(%rbp),%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x64(%rbp),%xmm0
ucomiss -0x6c(%rbp),%xmm0
jbe    12de <coplanar_tri_tri3d+0x1ce>
movss  -0x64(%rbp),%xmm0
ucomiss -0x68(%rbp),%xmm0
jb     12de <coplanar_tri_tri3d+0x1ce>
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x28(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x28(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x30(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x30(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x5c(%rbp)
jmp    144a <coplanar_tri_tri3d+0x33a>
movss  -0x68(%rbp),%xmm0
ucomiss -0x6c(%rbp),%xmm0
jbe    13a3 <coplanar_tri_tri3d+0x293>
movss  -0x68(%rbp),%xmm0
ucomiss -0x64(%rbp),%xmm0
jb     13a3 <coplanar_tri_tri3d+0x293>
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x28(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x30(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x30(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x5c(%rbp)
jmp    1445 <coplanar_tri_tri3d+0x335>
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x28(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x30(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x30(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x5c(%rbp)
jmp    144a <coplanar_tri_tri3d+0x33a>
lea    -0x38(%rbp),%rdi
lea    -0x40(%rbp),%rsi
lea    -0x48(%rbp),%rdx
lea    -0x50(%rbp),%rcx
lea    -0x58(%rbp),%r8
lea    -0x60(%rbp),%r9
call   1030 <tri_tri_overlap_test_2d@plt>
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<coplanar_tri_tri3d>:
sub    $0x38,%rsp
mov    0x40(%rsp),%rax
movss  (%rax),%xmm2
movss  0x4(%rax),%xmm3
movaps 0xed7(%rip),%xmm1
movaps %xmm2,%xmm4
xorps  %xmm1,%xmm4
xorps  %xmm5,%xmm5
movaps %xmm2,%xmm0
cmpltss %xmm5,%xmm0
andps  %xmm0,%xmm4
andnps %xmm2,%xmm0
orps   %xmm4,%xmm0
movaps %xmm3,%xmm4
xorps  %xmm1,%xmm4
movaps %xmm3,%xmm2
cmpltss %xmm5,%xmm2
andps  %xmm2,%xmm4
andnps %xmm3,%xmm2
orps   %xmm4,%xmm2
movss  0x8(%rax),%xmm4
xorps  %xmm4,%xmm1
movaps %xmm4,%xmm3
cmpltss %xmm5,%xmm3
andps  %xmm3,%xmm1
andnps %xmm4,%xmm3
orps   %xmm1,%xmm3
ucomiss %xmm3,%xmm0
jbe    11fc <coplanar_tri_tri3d+0xec>
ucomiss %xmm2,%xmm0
jb     11fc <coplanar_tri_tri3d+0xec>
movss  0x8(%rsi),%xmm0
movss  %xmm0,0x28(%rsp)
movss  0x4(%rsi),%xmm0
movss  %xmm0,0x2c(%rsp)
movss  0x8(%rdi),%xmm0
movss  %xmm0,0x20(%rsp)
movss  0x4(%rdi),%xmm0
movss  %xmm0,0x24(%rsp)
movss  0x8(%rdx),%xmm0
movss  %xmm0,0x18(%rsp)
movss  0x4(%rdx),%xmm0
movss  %xmm0,0x1c(%rsp)
movss  0x8(%r8),%xmm0
movss  %xmm0,0x10(%rsp)
movss  0x4(%r8),%xmm0
movss  %xmm0,0x14(%rsp)
movss  0x8(%rcx),%xmm0
movss  %xmm0,0x8(%rsp)
movss  0x4(%rcx),%xmm0
movss  %xmm0,0xc(%rsp)
movss  0x8(%r9),%xmm0
jmp    12f7 <coplanar_tri_tri3d+0x1e7>
ucomiss %xmm3,%xmm2
jbe    1287 <coplanar_tri_tri3d+0x177>
ucomiss %xmm0,%xmm2
jb     1287 <coplanar_tri_tri3d+0x177>
movss  (%rsi),%xmm0
movss  %xmm0,0x28(%rsp)
movss  0x8(%rsi),%xmm0
movss  %xmm0,0x2c(%rsp)
movss  (%rdi),%xmm0
movss  %xmm0,0x20(%rsp)
movss  0x8(%rdi),%xmm0
movss  %xmm0,0x24(%rsp)
movss  (%rdx),%xmm0
movss  %xmm0,0x18(%rsp)
movss  0x8(%rdx),%xmm0
movss  %xmm0,0x1c(%rsp)
movss  (%r8),%xmm0
movss  %xmm0,0x10(%rsp)
movss  0x8(%r8),%xmm0
movss  %xmm0,0x14(%rsp)
movss  (%rcx),%xmm0
movss  %xmm0,0x8(%rsp)
movss  0x8(%rcx),%xmm0
movss  %xmm0,0xc(%rsp)
movss  (%r9),%xmm0
movss  %xmm0,0x30(%rsp)
mov    $0x2,%eax
jmp    1302 <coplanar_tri_tri3d+0x1f2>
movss  (%rdi),%xmm0
movss  %xmm0,0x28(%rsp)
movss  0x4(%rdi),%xmm0
movss  %xmm0,0x2c(%rsp)
movss  (%rsi),%xmm0
movss  %xmm0,0x20(%rsp)
movss  0x4(%rsi),%xmm0
movss  %xmm0,0x24(%rsp)
movss  (%rdx),%xmm0
movss  %xmm0,0x18(%rsp)
movss  0x4(%rdx),%xmm0
movss  %xmm0,0x1c(%rsp)
movss  (%rcx),%xmm0
movss  %xmm0,0x10(%rsp)
movss  0x4(%rcx),%xmm0
movss  %xmm0,0x14(%rsp)
movss  (%r8),%xmm0
movss  %xmm0,0x8(%rsp)
movss  0x4(%r8),%xmm0
movss  %xmm0,0xc(%rsp)
movss  (%r9),%xmm0
movss  %xmm0,0x30(%rsp)
mov    $0x1,%eax
movss  (%r9,%rax,4),%xmm0
movss  %xmm0,0x34(%rsp)
lea    0x28(%rsp),%rdi
lea    0x20(%rsp),%rsi
lea    0x18(%rsp),%rdx
lea    0x10(%rsp),%rcx
lea    0x8(%rsp),%r8
lea    0x30(%rsp),%r9
call   1030 <tri_tri_overlap_test_2d@plt>
add    $0x38,%rsp
ret

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

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