void intersect2(float VTX0[3], float VTX1[3], float VTX2[3], float VV0,
                float VV1, float VV2, float D0, float D1, float D2,
                float *isect0, float *isect1, float isectpoint0[3],
                float isectpoint1[3]) {
  float tmp = D0 / (D0 - D1);
  float diff[3];
  *isect0 = VV0 + (VV1 - VV0) * tmp;
  diff[0] = VTX1[0] - VTX0[0];
  diff[1] = VTX1[1] - VTX0[1];
  diff[2] = VTX1[2] - VTX0[2];
  ;
  diff[0] = tmp * diff[0];
  diff[1] = tmp * diff[1];
  diff[2] = tmp * diff[2];
  ;
  isectpoint0[0] = diff[0] + VTX0[0];
  isectpoint0[1] = diff[1] + VTX0[1];
  isectpoint0[2] = diff[2] + VTX0[2];
  ;
  tmp = D0 / (D0 - D2);
  *isect1 = VV0 + (VV2 - VV0) * tmp;
  diff[0] = VTX2[0] - VTX0[0];
  diff[1] = VTX2[1] - VTX0[1];
  diff[2] = VTX2[2] - VTX0[2];
  ;
  diff[0] = tmp * diff[0];
  diff[1] = tmp * diff[1];
  diff[2] = tmp * diff[2];
  ;
  isectpoint1[0] = VTX0[0] + diff[0];
  isectpoint1[1] = VTX0[1] + diff[1];
  isectpoint1[2] = VTX0[2] + diff[2];
  ;
}


x86 assembly (clang, -O0):
<intersect2>:
push   %rbp
mov    %rsp,%rbp
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movss  %xmm0,-0x1c(%rbp)
movss  %xmm1,-0x20(%rbp)
movss  %xmm2,-0x24(%rbp)
movss  %xmm3,-0x28(%rbp)
movss  %xmm4,-0x2c(%rbp)
movss  %xmm5,-0x30(%rbp)
mov    %rcx,-0x38(%rbp)
mov    %r8,-0x40(%rbp)
mov    %r9,-0x48(%rbp)
movss  -0x28(%rbp),%xmm0
movss  -0x28(%rbp),%xmm1
subss  -0x2c(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x1c(%rbp),%xmm1
movss  -0x20(%rbp),%xmm0
subss  -0x1c(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x8(%rbp),%rax
subss  (%rax),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x8(%rbp),%rax
subss  0x4(%rax),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
subss  0x8(%rax),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x4c(%rbp),%xmm0
mulss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x4c(%rbp),%xmm0
mulss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x4c(%rbp),%xmm0
mulss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x58(%rbp),%xmm0
mov    -0x8(%rbp),%rax
addss  (%rax),%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x54(%rbp),%xmm0
mov    -0x8(%rbp),%rax
addss  0x4(%rax),%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x50(%rbp),%xmm0
mov    -0x8(%rbp),%rax
addss  0x8(%rax),%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x28(%rbp),%xmm0
movss  -0x28(%rbp),%xmm1
subss  -0x30(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x1c(%rbp),%xmm1
movss  -0x24(%rbp),%xmm0
subss  -0x1c(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x8(%rbp),%rax
subss  (%rax),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x8(%rbp),%rax
subss  0x4(%rax),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
subss  0x8(%rax),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x4c(%rbp),%xmm0
mulss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x4c(%rbp),%xmm0
mulss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x4c(%rbp),%xmm0
mulss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
addss  -0x58(%rbp),%xmm0
mov    0x10(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
addss  -0x54(%rbp),%xmm0
mov    0x10(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
addss  -0x50(%rbp),%xmm0
mov    0x10(%rbp),%rax
movss  %xmm0,0x8(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<intersect2>:
movaps %xmm3,%xmm6
subss  %xmm4,%xmm6
movaps %xmm3,%xmm4
divss  %xmm6,%xmm4
subss  %xmm0,%xmm1
mulss  %xmm4,%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%rcx)
movss  (%rdi),%xmm8
movss  (%rsi),%xmm6
movss  0x4(%rsi),%xmm7
subss  %xmm8,%xmm6
subss  0x4(%rdi),%xmm7
movss  0x8(%rsi),%xmm1
subss  0x8(%rdi),%xmm1
mulss  %xmm4,%xmm6
mulss  %xmm4,%xmm7
addss  %xmm8,%xmm6
movss  %xmm6,(%r9)
addss  0x4(%rdi),%xmm7
mulss  %xmm4,%xmm1
movss  %xmm7,0x4(%r9)
addss  0x8(%rdi),%xmm1
mov    0x8(%rsp),%rax
movss  %xmm1,0x8(%r9)
movaps %xmm3,%xmm1
subss  %xmm5,%xmm1
divss  %xmm1,%xmm3
subss  %xmm0,%xmm2
mulss  %xmm3,%xmm2
addss  %xmm0,%xmm2
movss  %xmm2,(%r8)
movss  (%rdi),%xmm0
movss  0x4(%rdx),%xmm1
subss  0x4(%rdi),%xmm1
movss  (%rdx),%xmm2
movss  0x8(%rdx),%xmm4
subss  0x8(%rdi),%xmm4
subss  %xmm0,%xmm2
mulss  %xmm3,%xmm2
mulss  %xmm3,%xmm1
mulss  %xmm3,%xmm4
addss  %xmm0,%xmm2
movss  %xmm2,(%rax)
addss  0x4(%rdi),%xmm1
movss  %xmm1,0x4(%rax)
addss  0x8(%rdi),%xmm4
movss  %xmm4,0x8(%rax)
ret

LLVM IR (-O0):
define void @intersect2(float* %0, float* %1, float* %2, float %3, float %4, float %5, float %6, float %7, float %8, float* %9, float* %10, float* %11, float* %12) {
%14 = alloca float*
%15 = alloca float*
%16 = alloca float*
%17 = alloca float
%18 = alloca float
%19 = alloca float
%20 = alloca float
%21 = alloca float
%22 = alloca float
%23 = alloca float*
%24 = alloca float*
%25 = alloca float*
%26 = alloca float*
%27 = alloca float
%28 = alloca [3 x float]
store float* %0, float** %14
store float* %1, float** %15
store float* %2, float** %16
store float %3, float* %17
store float %4, float* %18
store float %5, float* %19
store float %6, float* %20
store float %7, float* %21
store float %8, float* %22
store float* %9, float** %23
store float* %10, float** %24
store float* %11, float** %25
store float* %12, float** %26
%29 = load float, float* %20
%30 = load float, float* %20
%31 = load float, float* %21
%32 = fsub float %30, %31
%33 = fdiv float %29, %32
store float %33, float* %27
%34 = load float, float* %17
%35 = load float, float* %18
%36 = load float, float* %17
%37 = fsub float %35, %36
%38 = load float, float* %27
%39 = call float @llvm.fmuladd.f32(float %37, float %38, float %34)
%40 = load float*, float** %23
store float %39, float* %40
%41 = load float*, float** %15
%42 = getelementptr inbounds float, float* %41, i64 0
%43 = load float, float* %42
%44 = load float*, float** %14
%45 = getelementptr inbounds float, float* %44, i64 0
%46 = load float, float* %45
%47 = fsub float %43, %46
%48 = getelementptr inbounds [3 x float], [3 x float]* %28, i64 0, i64 0
store float %47, float* %48
%49 = load float*, float** %15
%50 = getelementptr inbounds float, float* %49, i64 1
%51 = load float, float* %50
%52 = load float*, float** %14
%53 = getelementptr inbounds float, float* %52, i64 1
%54 = load float, float* %53
%55 = fsub float %51, %54
%56 = getelementptr inbounds [3 x float], [3 x float]* %28, i64 0, i64 1
store float %55, float* %56
%57 = load float*, float** %15
%58 = getelementptr inbounds float, float* %57, i64 2
%59 = load float, float* %58
%60 = load float*, float** %14
%61 = getelementptr inbounds float, float* %60, i64 2
%62 = load float, float* %61
%63 = fsub float %59, %62
%64 = getelementptr inbounds [3 x float], [3 x float]* %28, i64 0, i64 2
store float %63, float* %64
%65 = load float, float* %27
%66 = getelementptr inbounds [3 x float], [3 x float]* %28, i64 0, i64 0
%67 = load float, float* %66
%68 = fmul float %65, %67
%69 = getelementptr inbounds [3 x float], [3 x float]* %28, i64 0, i64 0
store float %68, float* %69
%70 = load float, float* %27
%71 = getelementptr inbounds [3 x float], [3 x float]* %28, i64 0, i64 1
%72 = load float, float* %71
%73 = fmul float %70, %72
%74 = getelementptr inbounds [3 x float], [3 x float]* %28, i64 0, i64 1
store float %73, float* %74
%75 = load float, float* %27
%76 = getelementptr inbounds [3 x float], [3 x float]* %28, i64 0, i64 2
%77 = load float, float* %76
%78 = fmul float %75, %77
%79 = getelementptr inbounds [3 x float], [3 x float]* %28, i64 0, i64 2
store float %78, float* %79
%80 = getelementptr inbounds [3 x float], [3 x float]* %28, i64 0, i64 0
%81 = load float, float* %80
%82 = load float*, float** %14
%83 = getelementptr inbounds float, float* %82, i64 0
%84 = load float, float* %83
%85 = fadd float %81, %84
%86 = load float*, float** %25
%87 = getelementptr inbounds float, float* %86, i64 0
store float %85, float* %87
%88 = getelementptr inbounds [3 x float], [3 x float]* %28, i64 0, i64 1
%89 = load float, float* %88
%90 = load float*, float** %14
%91 = getelementptr inbounds float, float* %90, i64 1
%92 = load float, float* %91
%93 = fadd float %89, %92
%94 = load float*, float** %25
%95 = getelementptr inbounds float, float* %94, i64 1
store float %93, float* %95
%96 = getelementptr inbounds [3 x float], [3 x float]* %28, i64 0, i64 2
%97 = load float, float* %96
%98 = load float*, float** %14
%99 = getelementptr inbounds float, float* %98, i64 2
%100 = load float, float* %99
%101 = fadd float %97, %100
%102 = load float*, float** %25
%103 = getelementptr inbounds float, float* %102, i64 2
store float %101, float* %103
%104 = load float, float* %20
%105 = load float, float* %20
%106 = load float, float* %22
%107 = fsub float %105, %106
%108 = fdiv float %104, %107
store float %108, float* %27
%109 = load float, float* %17
%110 = load float, float* %19
%111 = load float, float* %17
%112 = fsub float %110, %111
%113 = load float, float* %27
%114 = call float @llvm.fmuladd.f32(float %112, float %113, float %109)
%115 = load float*, float** %24
store float %114, float* %115
%116 = load float*, float** %16
%117 = getelementptr inbounds float, float* %116, i64 0
%118 = load float, float* %117
%119 = load float*, float** %14
%120 = getelementptr inbounds float, float* %119, i64 0
%121 = load float, float* %120
%122 = fsub float %118, %121
%123 = getelementptr inbounds [3 x float], [3 x float]* %28, i64 0, i64 0
store float %122, float* %123
%124 = load float*, float** %16
%125 = getelementptr inbounds float, float* %124, i64 1
%126 = load float, float* %125
%127 = load float*, float** %14
%128 = getelementptr inbounds float, float* %127, i64 1
%129 = load float, float* %128
%130 = fsub float %126, %129
%131 = getelementptr inbounds [3 x float], [3 x float]* %28, i64 0, i64 1
store float %130, float* %131
%132 = load float*, float** %16
%133 = getelementptr inbounds float, float* %132, i64 2
%134 = load float, float* %133
%135 = load float*, float** %14
%136 = getelementptr inbounds float, float* %135, i64 2
%137 = load float, float* %136
%138 = fsub float %134, %137
%139 = getelementptr inbounds [3 x float], [3 x float]* %28, i64 0, i64 2
store float %138, float* %139
%140 = load float, float* %27
%141 = getelementptr inbounds [3 x float], [3 x float]* %28, i64 0, i64 0
%142 = load float, float* %141
%143 = fmul float %140, %142
%144 = getelementptr inbounds [3 x float], [3 x float]* %28, i64 0, i64 0
store float %143, float* %144
%145 = load float, float* %27
%146 = getelementptr inbounds [3 x float], [3 x float]* %28, i64 0, i64 1
%147 = load float, float* %146
%148 = fmul float %145, %147
%149 = getelementptr inbounds [3 x float], [3 x float]* %28, i64 0, i64 1
store float %148, float* %149
%150 = load float, float* %27
%151 = getelementptr inbounds [3 x float], [3 x float]* %28, i64 0, i64 2
%152 = load float, float* %151
%153 = fmul float %150, %152
%154 = getelementptr inbounds [3 x float], [3 x float]* %28, i64 0, i64 2
store float %153, float* %154
%155 = load float*, float** %14
%156 = getelementptr inbounds float, float* %155, i64 0
%157 = load float, float* %156
%158 = getelementptr inbounds [3 x float], [3 x float]* %28, i64 0, i64 0
%159 = load float, float* %158
%160 = fadd float %157, %159
%161 = load float*, float** %26
%162 = getelementptr inbounds float, float* %161, i64 0
store float %160, float* %162
%163 = load float*, float** %14
%164 = getelementptr inbounds float, float* %163, i64 1
%165 = load float, float* %164
%166 = getelementptr inbounds [3 x float], [3 x float]* %28, i64 0, i64 1
%167 = load float, float* %166
%168 = fadd float %165, %167
%169 = load float*, float** %26
%170 = getelementptr inbounds float, float* %169, i64 1
store float %168, float* %170
%171 = load float*, float** %14
%172 = getelementptr inbounds float, float* %171, i64 2
%173 = load float, float* %172
%174 = getelementptr inbounds [3 x float], [3 x float]* %28, i64 0, i64 2
%175 = load float, float* %174
%176 = fadd float %173, %175
%177 = load float*, float** %26
%178 = getelementptr inbounds float, float* %177, i64 2
store float %176, float* %178
ret void
}

LLVM IR (-O2):
define void @intersect2(float* nocapture %0, float* nocapture %1, float* nocapture %2, float %3, float %4, float %5, float %6, float %7, float %8, float* nocapture writeonly %9, float* nocapture writeonly %10, float* nocapture writeonly %11, float* nocapture writeonly %12) {
%14 = fsub float %6, %7
%15 = fdiv float %6, %14
%16 = fsub float %4, %3
%17 = tail call float @llvm.fmuladd.f32(float %16, float %15, float %3)
store float %17, float* %9
%18 = load float, float* %1
%19 = load float, float* %0
%20 = fsub float %18, %19
%21 = getelementptr inbounds float, float* %1, i64 1
%22 = load float, float* %21
%23 = getelementptr inbounds float, float* %0, i64 1
%24 = load float, float* %23
%25 = fsub float %22, %24
%26 = getelementptr inbounds float, float* %1, i64 2
%27 = load float, float* %26
%28 = getelementptr inbounds float, float* %0, i64 2
%29 = load float, float* %28
%30 = fsub float %27, %29
%31 = fmul float %15, %20
%32 = fmul float %15, %25
%33 = fmul float %15, %30
%34 = fadd float %19, %31
store float %34, float* %11
%35 = load float, float* %23
%36 = fadd float %32, %35
%37 = getelementptr inbounds float, float* %11, i64 1
store float %36, float* %37
%38 = load float, float* %28
%39 = fadd float %33, %38
%40 = getelementptr inbounds float, float* %11, i64 2
store float %39, float* %40
%41 = fsub float %6, %8
%42 = fdiv float %6, %41
%43 = fsub float %5, %3
%44 = tail call float @llvm.fmuladd.f32(float %43, float %42, float %3)
store float %44, float* %10
%45 = load float, float* %2
%46 = load float, float* %0
%47 = fsub float %45, %46
%48 = getelementptr inbounds float, float* %2, i64 1
%49 = load float, float* %48
%50 = load float, float* %23
%51 = fsub float %49, %50
%52 = getelementptr inbounds float, float* %2, i64 2
%53 = load float, float* %52
%54 = load float, float* %28
%55 = fsub float %53, %54
%56 = fmul float %42, %47
%57 = fmul float %42, %51
%58 = fmul float %42, %55
%59 = fadd float %46, %56
store float %59, float* %12
%60 = load float, float* %23
%61 = fadd float %57, %60
%62 = getelementptr inbounds float, float* %12, i64 1
store float %61, float* %62
%63 = load float, float* %28
%64 = fadd float %58, %63
%65 = getelementptr inbounds float, float* %12, i64 2
store float %64, float* %65
ret void
}