#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 */
float VectorProduct(float *, float *, float *);
float fabs(float);
float sqrt(float);
void Project4_123(float *Coord1, float *Coord2, float *Coord3, float *Coord4,
                  float *Coord_Proj4_123) {
  float Vector21[3], Vector23[3], Vector14[3], VectorNormal_123[3];
  float Length_21 = 0.0, Length_23 = 0.0, Length_14 = 0.0, NormalLength;
  float COS_Norm_14, Proj_14_Norm;
  int i;
  for (i = 0; i < 3; i++) {
    Vector21[i] = Coord1[i] - Coord2[i];
    Vector23[i] = Coord3[i] - Coord2[i];
    Vector14[i] = Coord4[i] - Coord1[i];
    Length_21 += Vector21[i] * Vector21[i];
    Length_23 += Vector23[i] * Vector23[i];
    Length_14 += Vector14[i] * Vector14[i];
  }
  Length_21 = sqrt(Length_21);
  Length_23 = sqrt(Length_23);
  Length_14 = sqrt(Length_14);
  NormalLength = VectorProduct(Vector21, Vector23, VectorNormal_123);
  for (i = 0; i < 3; i++)
    VectorNormal_123[i] /= NormalLength;
  COS_Norm_14 = 0.0;
  for (i = 0; i < 3; i++)
    COS_Norm_14 += VectorNormal_123[i] * Vector14[i];
  COS_Norm_14 /= (Length_14 * NormalLength);
  if (COS_Norm_14 < 0.0) {
    COS_Norm_14 = fabs(COS_Norm_14);
    for (i = 0; i < 3; i++)
      VectorNormal_123[i] = -VectorNormal_123[i];
  }
  Proj_14_Norm = Length_14 * COS_Norm_14;
  for (i = 0; i < 3; i++) {
    VectorNormal_123[i] *= Proj_14_Norm;
    Coord_Proj4_123[i] = (Vector14[i] - VectorNormal_123[i]) + Coord1[i];
  }
}


x86 assembly (clang, -O0):
<Project4_123>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x5c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x60(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x64(%rbp)
movl   $0x0,-0x74(%rbp)
cmpl   $0x3,-0x74(%rbp)
jge    1264 <Project4_123+0x134>
mov    -0x8(%rbp),%rax
movslq -0x74(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x74(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movslq -0x74(%rbp),%rax
movss  %xmm0,-0x34(%rbp,%rax,4)
mov    -0x18(%rbp),%rax
movslq -0x74(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x74(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movslq -0x74(%rbp),%rax
movss  %xmm0,-0x40(%rbp,%rax,4)
mov    -0x20(%rbp),%rax
movslq -0x74(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x74(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movslq -0x74(%rbp),%rax
movss  %xmm0,-0x4c(%rbp,%rax,4)
movslq -0x74(%rbp),%rax
movss  -0x34(%rbp,%rax,4),%xmm0
movslq -0x74(%rbp),%rax
movss  -0x34(%rbp,%rax,4),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movslq -0x74(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm0
movslq -0x74(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movslq -0x74(%rbp),%rax
movss  -0x4c(%rbp,%rax,4),%xmm0
movslq -0x74(%rbp),%rax
movss  -0x4c(%rbp,%rax,4),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    116e <Project4_123+0x3e>
movss  -0x5c(%rbp),%xmm0
call   1050 <sqrt@plt>
movss  %xmm0,-0x5c(%rbp)
movss  -0x60(%rbp),%xmm0
call   1050 <sqrt@plt>
movss  %xmm0,-0x60(%rbp)
movss  -0x64(%rbp),%xmm0
call   1050 <sqrt@plt>
movss  %xmm0,-0x64(%rbp)
lea    -0x34(%rbp),%rdi
lea    -0x40(%rbp),%rsi
lea    -0x58(%rbp),%rdx
call   1030 <VectorProduct@plt>
movss  %xmm0,-0x68(%rbp)
movl   $0x0,-0x74(%rbp)
cmpl   $0x3,-0x74(%rbp)
jge    12df <Project4_123+0x1af>
movss  -0x68(%rbp),%xmm1
movslq -0x74(%rbp),%rax
movss  -0x58(%rbp,%rax,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp,%rax,4)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    12ae <Project4_123+0x17e>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x6c(%rbp)
movl   $0x0,-0x74(%rbp)
cmpl   $0x3,-0x74(%rbp)
jge    132c <Project4_123+0x1fc>
movslq -0x74(%rbp),%rax
movss  -0x58(%rbp,%rax,4),%xmm0
movslq -0x74(%rbp),%rax
movss  -0x4c(%rbp,%rax,4),%xmm2
movss  -0x6c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    12ee <Project4_123+0x1be>
movss  -0x64(%rbp),%xmm1
mulss  -0x68(%rbp),%xmm1
movss  -0x6c(%rbp),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x6c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    13ae <Project4_123+0x27e>
movss  -0x6c(%rbp),%xmm0
call   1040 <fabs@plt>
movss  %xmm0,-0x6c(%rbp)
movl   $0x0,-0x74(%rbp)
cmpl   $0x3,-0x74(%rbp)
jge    13a9 <Project4_123+0x279>
movslq -0x74(%rbp),%rax
movss  -0x58(%rbp,%rax,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movslq -0x74(%rbp),%rax
movss  %xmm0,-0x58(%rbp,%rax,4)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    1370 <Project4_123+0x240>
jmp    13ae <Project4_123+0x27e>
movss  -0x64(%rbp),%xmm0
mulss  -0x6c(%rbp),%xmm0
movss  %xmm0,-0x70(%rbp)
movl   $0x0,-0x74(%rbp)
cmpl   $0x3,-0x74(%rbp)
jge    141f <Project4_123+0x2ef>
movss  -0x70(%rbp),%xmm0
movslq -0x74(%rbp),%rax
mulss  -0x58(%rbp,%rax,4),%xmm0
movss  %xmm0,-0x58(%rbp,%rax,4)
movslq -0x74(%rbp),%rax
movss  -0x4c(%rbp,%rax,4),%xmm0
movslq -0x74(%rbp),%rax
subss  -0x58(%rbp,%rax,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x74(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x74(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    13c4 <Project4_123+0x294>
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Project4_123>:
push   %r14
push   %rbx
sub    $0x38,%rsp
mov    %r8,%r14
mov    %rdi,%rbx
movss  (%rdi),%xmm0
movss  (%rsi),%xmm1
movaps %xmm0,%xmm2
subss  %xmm1,%xmm2
movss  %xmm2,0x1c(%rsp)
movss  (%rdx),%xmm2
subss  %xmm1,%xmm2
movss  %xmm2,0x10(%rsp)
movss  (%rcx),%xmm1
subss  %xmm0,%xmm1
movss  %xmm1,0xc(%rsp)
movaps %xmm1,%xmm0
mulss  %xmm1,%xmm0
xorps  %xmm4,%xmm4
addss  %xmm4,%xmm0
movss  0x4(%rdi),%xmm1
movss  0x4(%rsi),%xmm2
movaps %xmm1,%xmm3
subss  %xmm2,%xmm3
movss  %xmm3,0x20(%rsp)
movss  0x4(%rdx),%xmm3
subss  %xmm2,%xmm3
movss  %xmm3,0x14(%rsp)
movss  0x4(%rcx),%xmm2
subss  %xmm1,%xmm2
movss  %xmm2,0x8(%rsp)
movaps %xmm2,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0x8(%rdi),%xmm0
movss  0x8(%rsi),%xmm2
movaps %xmm0,%xmm3
subss  %xmm2,%xmm3
movss  %xmm3,0x24(%rsp)
movss  0x8(%rdx),%xmm3
subss  %xmm2,%xmm3
movss  %xmm3,0x18(%rsp)
movss  0x8(%rcx),%xmm2
subss  %xmm0,%xmm2
movss  %xmm2,0x4(%rsp)
movaps %xmm2,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
ucomiss %xmm4,%xmm0
jb     11f7 <Project4_123+0xd7>
sqrtss %xmm0,%xmm0
jmp    11fc <Project4_123+0xdc>
call   1040 <sqrt@plt>
movss  %xmm0,(%rsp)
lea    0x1c(%rsp),%rdi
lea    0x10(%rsp),%rsi
lea    0x28(%rsp),%rdx
call   1030 <VectorProduct@plt>
movsd  0x28(%rsp),%xmm1
movaps %xmm0,%xmm2
shufps $0x0,%xmm0,%xmm2
divps  %xmm2,%xmm1
movss  0x30(%rsp),%xmm4
divss  %xmm0,%xmm4
movaps %xmm1,%xmm2
movss  0xc(%rsp),%xmm6
mulss  %xmm6,%xmm2
xorps  %xmm9,%xmm9
addss  %xmm9,%xmm2
movaps %xmm1,%xmm3
shufps $0x55,%xmm1,%xmm3
movss  0x8(%rsp),%xmm7
mulss  %xmm7,%xmm3
addss  %xmm2,%xmm3
movaps %xmm4,%xmm2
movss  0x4(%rsp),%xmm8
mulss  %xmm8,%xmm2
addss  %xmm3,%xmm2
movss  (%rsp),%xmm3
mulss  %xmm3,%xmm0
divss  %xmm0,%xmm2
ucomiss %xmm2,%xmm9
movaps 0xd7a(%rip),%xmm10
movaps %xmm4,%xmm5
xorps  %xmm10,%xmm5
movaps %xmm2,%xmm0
cmpltss %xmm9,%xmm0
andps  %xmm0,%xmm5
andnps %xmm4,%xmm0
orps   %xmm5,%xmm0
movaps %xmm3,%xmm4
jbe    12af <Project4_123+0x18f>
xorps  %xmm10,%xmm1
andps  0xd61(%rip),%xmm2
mulss  %xmm2,%xmm4
movaps %xmm4,%xmm2
mulss  %xmm1,%xmm2
subss  %xmm2,%xmm6
addss  (%rbx),%xmm6
movss  %xmm6,(%r14)
shufps $0x55,%xmm1,%xmm1
mulss  %xmm4,%xmm1
subss  %xmm1,%xmm7
addss  0x4(%rbx),%xmm7
movss  %xmm7,0x4(%r14)
mulss  %xmm0,%xmm4
subss  %xmm4,%xmm8
addss  0x8(%rbx),%xmm8
movss  %xmm8,0x8(%r14)
add    $0x38,%rsp
pop    %rbx
pop    %r14
ret

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

LLVM IR (-O2):
define void @Project4_123(float* nocapture %0, float* nocapture %1, float* nocapture %2, float* nocapture %3, float* nocapture writeonly %4) {
%6 = alloca [3 x float]
%7 = alloca [3 x float]
%8 = alloca [3 x float]
%9 = bitcast [3 x float]* %6 to i8*
%10 = bitcast [3 x float]* %7 to i8*
%11 = bitcast [3 x float]* %8 to i8*
%12 = load float, float* %0
%13 = load float, float* %1
%14 = fsub float %12, %13
%15 = getelementptr inbounds [3 x float], [3 x float]* %6, i64 0, i64 0
store float %14, float* %15
%16 = load float, float* %2
%17 = fsub float %16, %13
%18 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 0
store float %17, float* %18
%19 = load float, float* %3
%20 = fsub float %19, %12
%21 = tail call float @llvm.fmuladd.f32(float %20, float %20, float 0.000000e+00)
%22 = getelementptr inbounds float, float* %0, i64 1
%23 = load float, float* %22
%24 = getelementptr inbounds float, float* %1, i64 1
%25 = load float, float* %24
%26 = fsub float %23, %25
%27 = getelementptr inbounds [3 x float], [3 x float]* %6, i64 0, i64 1
store float %26, float* %27
%28 = getelementptr inbounds float, float* %2, i64 1
%29 = load float, float* %28
%30 = fsub float %29, %25
%31 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 1
store float %30, float* %31
%32 = getelementptr inbounds float, float* %3, i64 1
%33 = load float, float* %32
%34 = fsub float %33, %23
%35 = tail call float @llvm.fmuladd.f32(float %34, float %34, float %21)
%36 = getelementptr inbounds float, float* %0, i64 2
%37 = load float, float* %36
%38 = getelementptr inbounds float, float* %1, i64 2
%39 = load float, float* %38
%40 = fsub float %37, %39
%41 = getelementptr inbounds [3 x float], [3 x float]* %6, i64 0, i64 2
store float %40, float* %41
%42 = getelementptr inbounds float, float* %2, i64 2
%43 = load float, float* %42
%44 = fsub float %43, %39
%45 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 2
store float %44, float* %45
%46 = getelementptr inbounds float, float* %3, i64 2
%47 = load float, float* %46
%48 = fsub float %47, %37
%49 = tail call float @llvm.fmuladd.f32(float %48, float %48, float %35)
%50 = tail call float @sqrt(float %49)
%51 = getelementptr inbounds [3 x float], [3 x float]* %8, i64 0, i64 0
%52 = call float @VectorProduct(float* %15, float* %18, float* %51)
%53 = bitcast [3 x float]* %8 to <2 x float>*
%54 = load <2 x float>, <2 x float>* %53
%55 = insertelement <2 x float> poison, float %52, i64 0
%56 = shufflevector <2 x float> %55, <2 x float> poison, <2 x i32> zeroinitializer
%57 = fdiv <2 x float> %54, %56
%58 = getelementptr inbounds [3 x float], [3 x float]* %8, i64 0, i64 2
%59 = load float, float* %58
%60 = fdiv float %59, %52
%61 = extractelement <2 x float> %57, i64 0
%62 = call float @llvm.fmuladd.f32(float %61, float %20, float 0.000000e+00)
%63 = extractelement <2 x float> %57, i64 1
%64 = call float @llvm.fmuladd.f32(float %63, float %34, float %62)
%65 = call float @llvm.fmuladd.f32(float %60, float %48, float %64)
%66 = fmul float %50, %52
%67 = fdiv float %65, %66
%68 = fcmp olt float %67, 0.000000e+00
%69 = fneg <2 x float> %57
%70 = fneg float %60
%71 = call float @llvm.fabs.f32(float %67)
%72 = select i1 %68, float %70, float %60
%73 = select i1 %68, float %71, float %67
%74 = select i1 %68, <2 x float> %69, <2 x float> %57
%75 = fmul float %50, %73
%76 = extractelement <2 x float> %74, i64 0
%77 = fmul float %75, %76
%78 = fsub float %20, %77
%79 = load float, float* %0
%80 = fadd float %78, %79
store float %80, float* %4
%81 = extractelement <2 x float> %74, i64 1
%82 = fmul float %75, %81
%83 = fsub float %34, %82
%84 = load float, float* %22
%85 = fadd float %83, %84
%86 = getelementptr inbounds float, float* %4, i64 1
store float %85, float* %86
%87 = fmul float %75, %72
%88 = fsub float %48, %87
%89 = load float, float* %36
%90 = fadd float %88, %89
%91 = getelementptr inbounds float, float* %4, i64 2
store float %90, float* %91
ret void
}