#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 /*<<< orphan*/ CalcOutProduct(float *, float *, float *);
float CalcVecSize(float *);
double fabs(float);
bool CalcIntersectionLine2(float vec1[3], float d1, float vec2[3], float d2,
                           float pos[3], float vec[3]) {
  float vec_wk[3];
  CalcOutProduct(vec1, vec2, vec_wk);
  float len = CalcVecSize(vec_wk);
  if (len < (1.0e-5)) {
    return false;
  }
  vec[0] = vec_wk[0] / len;
  vec[1] = vec_wk[1] / len;
  vec[2] = vec_wk[2] / len;
  if (fabs(vec[2]) > 0.5) {
    pos[0] = (d1 * vec2[1] - d2 * vec1[1]) / vec_wk[2];
    pos[1] = (d1 * vec2[0] - d2 * vec1[0]) / (-vec_wk[2]);
    pos[2] = 0.0;
  } else if (fabs(vec[1]) > 0.5) {
    pos[0] = (d1 * vec2[2] - d2 * vec1[2]) / (-vec_wk[1]);
    pos[1] = 0.0;
    pos[2] = (d1 * vec2[0] - d2 * vec1[0]) / vec_wk[1];
  } else if (fabs(vec[0]) > 0.5) {
    pos[0] = 0.0;
    pos[1] = (d1 * vec2[2] - d2 * vec1[2]) / vec_wk[0];
    pos[2] = (d1 * vec2[1] - d2 * vec1[1]) / (-vec_wk[0]);
  } else {
    return false;
  }
  return true;
}


x86 assembly (clang, -O0):
<CalcIntersectionLine2>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x10(%rbp)
movss  %xmm0,-0x14(%rbp)
mov    %rsi,-0x20(%rbp)
movss  %xmm1,-0x24(%rbp)
mov    %rdx,-0x30(%rbp)
mov    %rcx,-0x38(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x20(%rbp),%rsi
lea    -0x44(%rbp),%rdx
call   1050 <CalcOutProduct@plt>
lea    -0x44(%rbp),%rdi
call   1030 <CalcVecSize@plt>
movss  %xmm0,-0x48(%rbp)
movss  -0x48(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xe7e(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1198 <CalcIntersectionLine2+0x68>
movl   $0x0,-0x4(%rbp)
jmp    1425 <CalcIntersectionLine2+0x2f5>
movss  -0x44(%rbp),%xmm0
divss  -0x48(%rbp),%xmm0
mov    -0x38(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x40(%rbp),%xmm0
divss  -0x48(%rbp),%xmm0
mov    -0x38(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x3c(%rbp),%xmm0
divss  -0x48(%rbp),%xmm0
mov    -0x38(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0x38(%rbp),%rax
movss  0x8(%rax),%xmm0
call   1040 <fabs@plt>
movsd  0xe22(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    128d <CalcIntersectionLine2+0x15d>
movss  -0x14(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm2
movss  -0x24(%rbp),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x4(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
divss  -0x3c(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x14(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x24(%rbp),%xmm1
mov    -0x10(%rbp),%rax
mulss  (%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x3c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
divss  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x30(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x8(%rax)
jmp    141e <CalcIntersectionLine2+0x2ee>
mov    -0x38(%rbp),%rax
movss  0x4(%rax),%xmm0
call   1040 <fabs@plt>
movsd  0xd65(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    134a <CalcIntersectionLine2+0x21a>
movss  -0x14(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm2
movss  -0x24(%rbp),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x8(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x40(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
divss  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x30(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x4(%rax)
movss  -0x14(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x24(%rbp),%xmm1
mov    -0x10(%rbp),%rax
mulss  (%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
divss  -0x40(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movss  %xmm0,0x8(%rax)
jmp    1419 <CalcIntersectionLine2+0x2e9>
mov    -0x38(%rbp),%rax
movss  (%rax),%xmm0
call   1040 <fabs@plt>
movsd  0xca9(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1408 <CalcIntersectionLine2+0x2d8>
mov    -0x30(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax)
movss  -0x14(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm2
movss  -0x24(%rbp),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x8(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
divss  -0x44(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x14(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm2
movss  -0x24(%rbp),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x4(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x44(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
divss  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
movss  %xmm0,0x8(%rax)
jmp    1414 <CalcIntersectionLine2+0x2e4>
movl   $0x0,-0x4(%rbp)
jmp    1425 <CalcIntersectionLine2+0x2f5>
jmp    1419 <CalcIntersectionLine2+0x2e9>
jmp    141e <CalcIntersectionLine2+0x2ee>
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<CalcIntersectionLine2>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x20,%rsp
mov    %rcx,%rbx
mov    %rdx,%r14
movss  %xmm1,0xc(%rsp)
mov    %rsi,%r15
movss  %xmm0,0x10(%rsp)
mov    %rdi,%r12
lea    0x14(%rsp),%rbp
mov    %rbp,%rdx
call   1050 <CalcOutProduct@plt>
mov    %rbp,%rdi
call   1030 <CalcVecSize@plt>
xorps  %xmm1,%xmm1
cvtss2sd %xmm0,%xmm1
xor    %ebp,%ebp
movsd  0xe86(%rip),%xmm2
ucomisd %xmm1,%xmm2
ja     12ff <CalcIntersectionLine2+0x1cf>
movss  0x14(%rsp),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,(%rbx)
movss  0x18(%rsp),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0x4(%rbx)
movss  0x1c(%rsp),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0x8(%rbx)
movaps %xmm1,%xmm0
call   1040 <fabs@plt>
ucomisd 0xe48(%rip),%xmm0
jbe    121e <CalcIntersectionLine2+0xee>
movss  0x4(%r12),%xmm0
movss  0xc(%rsp),%xmm3
mulss  %xmm3,%xmm0
movss  0x4(%r15),%xmm1
movss  0x10(%rsp),%xmm2
mulss  %xmm2,%xmm1
subss  %xmm0,%xmm1
movss  0x1c(%rsp),%xmm0
divss  %xmm0,%xmm1
movss  %xmm1,(%r14)
mulss  (%r12),%xmm3
mulss  (%r15),%xmm2
xorps  0xe08(%rip),%xmm0
subss  %xmm3,%xmm2
divss  %xmm0,%xmm2
movss  %xmm2,0x4(%r14)
xorps  %xmm3,%xmm3
jmp    12f4 <CalcIntersectionLine2+0x1c4>
movss  0x4(%rbx),%xmm0
call   1040 <fabs@plt>
ucomisd 0xdd8(%rip),%xmm0
jbe    1289 <CalcIntersectionLine2+0x159>
movss  0x8(%r12),%xmm0
movss  0xc(%rsp),%xmm4
mulss  %xmm4,%xmm0
movss  0x8(%r15),%xmm1
movss  0x10(%rsp),%xmm3
mulss  %xmm3,%xmm1
subss  %xmm0,%xmm1
movss  0x18(%rsp),%xmm0
movaps 0xdac(%rip),%xmm2
xorps  %xmm0,%xmm2
divss  %xmm2,%xmm1
movss  %xmm1,(%r14)
movl   $0x0,0x4(%r14)
mulss  (%r12),%xmm4
mulss  (%r15),%xmm3
subss  %xmm4,%xmm3
jmp    12f0 <CalcIntersectionLine2+0x1c0>
movss  (%rbx),%xmm0
call   1040 <fabs@plt>
ucomisd 0xd6e(%rip),%xmm0
jbe    12ff <CalcIntersectionLine2+0x1cf>
movl   $0x0,(%r14)
movss  0x8(%r12),%xmm0
movss  0xc(%rsp),%xmm2
mulss  %xmm2,%xmm0
movss  0x8(%r15),%xmm1
movss  0x10(%rsp),%xmm3
mulss  %xmm3,%xmm1
subss  %xmm0,%xmm1
movss  0x14(%rsp),%xmm0
divss  %xmm0,%xmm1
movss  %xmm1,0x4(%r14)
mulss  0x4(%r12),%xmm2
mulss  0x4(%r15),%xmm3
subss  %xmm2,%xmm3
xorps  0xd20(%rip),%xmm0
divss  %xmm0,%xmm3
movss  %xmm3,0x8(%r14)
mov    $0x1,%ebp
mov    %ebp,%eax
add    $0x20,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define i32 @CalcIntersectionLine2(float* %0, float %1, float* %2, float %3, float* nocapture writeonly %4, float* nocapture %5) {
%7 = alloca [3 x float]
%8 = bitcast [3 x float]* %7 to i8*
%9 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 0
%10 = call i32 @CalcOutProduct(float* %0, float* %2, float* %9)
%11 = call float @CalcVecSize(float* %9)
%12 = fpext float %11 to double
%13 = fcmp olt double %12, 1.000000e-05
br i1 %13, label %94, label %14
14: ; preds = %6
%15 = load float, float* %9
%16 = fdiv float %15, %11
store float %16, float* %5
%17 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 1
%18 = load float, float* %17
%19 = fdiv float %18, %11
%20 = getelementptr inbounds float, float* %5, i64 1
store float %19, float* %20
%21 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 2
%22 = load float, float* %21
%23 = fdiv float %22, %11
%24 = getelementptr inbounds float, float* %5, i64 2
store float %23, float* %24
%25 = call double @fabs(float %23)
%26 = fcmp ogt double %25, 5.000000e-01
br i1 %26, label %27, label %45
27: ; preds = %14
%28 = getelementptr inbounds float, float* %2, i64 1
%29 = load float, float* %28
%30 = getelementptr inbounds float, float* %0, i64 1
%31 = load float, float* %30
%32 = fneg float %31
%33 = fmul float %32, %3
%34 = call float @llvm.fmuladd.f32(float %1, float %29, float %33)
%35 = load float, float* %21
%36 = fdiv float %34, %35
store float %36, float* %4
%37 = load float, float* %2
%38 = load float, float* %0
%39 = fneg float %38
%40 = fmul float %39, %3
%41 = call float @llvm.fmuladd.f32(float %1, float %37, float %40)
%42 = fneg float %35
%43 = fdiv float %41, %42
%44 = getelementptr inbounds float, float* %4, i64 1
store float %43, float* %44
br label %91
45: ; preds = %14
%46 = load float, float* %20
%47 = call double @fabs(float %46)
%48 = fcmp ogt double %47, 5.000000e-01
br i1 %48, label %49, label %67
49: ; preds = %45
%50 = getelementptr inbounds float, float* %2, i64 2
%51 = load float, float* %50
%52 = getelementptr inbounds float, float* %0, i64 2
%53 = load float, float* %52
%54 = fneg float %53
%55 = fmul float %54, %3
%56 = call float @llvm.fmuladd.f32(float %1, float %51, float %55)
%57 = load float, float* %17
%58 = fneg float %57
%59 = fdiv float %56, %58
store float %59, float* %4
%60 = getelementptr inbounds float, float* %4, i64 1
store float 0.000000e+00, float* %60
%61 = load float, float* %2
%62 = load float, float* %0
%63 = fneg float %62
%64 = fmul float %63, %3
%65 = call float @llvm.fmuladd.f32(float %1, float %61, float %64)
%66 = fdiv float %65, %57
br label %91
67: ; preds = %45
%68 = load float, float* %5
%69 = call double @fabs(float %68)
%70 = fcmp ogt double %69, 5.000000e-01
br i1 %70, label %71, label %94
71: ; preds = %67
store float 0.000000e+00, float* %4
%72 = getelementptr inbounds float, float* %2, i64 2
%73 = load float, float* %72
%74 = getelementptr inbounds float, float* %0, i64 2
%75 = load float, float* %74
%76 = fneg float %75
%77 = fmul float %76, %3
%78 = call float @llvm.fmuladd.f32(float %1, float %73, float %77)
%79 = load float, float* %9
%80 = fdiv float %78, %79
%81 = getelementptr inbounds float, float* %4, i64 1
store float %80, float* %81
%82 = getelementptr inbounds float, float* %2, i64 1
%83 = load float, float* %82
%84 = getelementptr inbounds float, float* %0, i64 1
%85 = load float, float* %84
%86 = fneg float %85
%87 = fmul float %86, %3
%88 = call float @llvm.fmuladd.f32(float %1, float %83, float %87)
%89 = fneg float %79
%90 = fdiv float %88, %89
br label %91
91: ; preds = %49, %71, %27
%92 = phi float [ 0.000000e+00, %27 ], [ %90, %71 ], [ %66, %49 ]
%93 = getelementptr inbounds float, float* %4, i64 2
store float %92, float* %93
br label %94
94: ; preds = %91, %67, %6
%95 = phi i32 [ 0, %6 ], [ 0, %67 ], [ 1, %91 ]
ret i32 %95
}