#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 sqrt(float);
float point_nearest_line(float a[3], float da[3], float b[3], float db[3]) {
  float dc[3], mc;
  float m[3][3], det, t;
  {
    dc[0] = da[1] * db[2] - da[2] * db[1];
    dc[1] = -da[0] * db[2] + da[2] * db[0];
    dc[2] = da[0] * db[1] - da[1] * db[0];
  };
  mc = sqrt(dc[0] * dc[0] + dc[1] * dc[1] + dc[2] * dc[2]);
  if (mc <= 0.0001) {
    return 0.0;
  } else {
    m[0][0] = b[0] - a[0];
    m[0][1] = b[1] - a[1];
    m[0][2] = b[2] - a[2];
    m[1][0] = db[0];
    m[1][1] = db[1];
    m[1][2] = db[2];
    m[2][0] = dc[0];
    m[2][1] = dc[1];
    m[2][2] = dc[2];
    det = m[0][0] * (m[1][1] * m[2][2] - m[1][2] * m[2][1]) -
          m[0][1] * (m[1][0] * m[2][2] - m[1][2] * m[2][0]) +
          m[0][2] * (m[1][0] * m[2][1] - m[1][1] * m[2][0]);
    t = det / (mc * mc);
    return t;
  }
}


x86 assembly (clang, -O0):
<point_nearest_line>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x28(%rbp),%rax
movss  0x8(%rax),%xmm2
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm1
mov    -0x28(%rbp),%rax
mulss  0x4(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x28(%rbp),%rax
movss  0x8(%rax),%xmm2
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm1
mov    -0x28(%rbp),%rax
mulss  (%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x28(%rbp),%rax
movss  0x4(%rax),%xmm2
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm1
mov    -0x28(%rbp),%rax
mulss  (%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x34(%rbp),%xmm1
movss  -0x34(%rbp),%xmm2
movss  -0x30(%rbp),%xmm0
mulss  -0x30(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x2c(%rbp),%xmm0
movss  -0x2c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
call   1030 <sqrt@plt>
movss  %xmm0,-0x38(%rbp)
movss  -0x38(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xdd9(%rip),%xmm0
ucomisd %xmm1,%xmm0
jb     123e <point_nearest_line+0x12e>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x4(%rbp)
jmp    139a <point_nearest_line+0x28a>
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
subss  (%rax),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
subss  0x4(%rax),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
subss  0x8(%rax),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x28(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x28(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x60(%rbp),%xmm1
movss  -0x50(%rbp),%xmm2
movss  -0x40(%rbp),%xmm3
movss  -0x4c(%rbp),%xmm0
mulss  -0x44(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm3,%xmm2
addss  %xmm0,%xmm2
movss  -0x5c(%rbp),%xmm0
movss  -0x54(%rbp),%xmm3
movss  -0x40(%rbp),%xmm5
movss  -0x4c(%rbp),%xmm4
mulss  -0x48(%rbp),%xmm4
movd   %xmm4,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm4
mulss  %xmm5,%xmm3
addss  %xmm4,%xmm3
mulss  %xmm3,%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x58(%rbp),%xmm0
movss  -0x54(%rbp),%xmm2
movss  -0x44(%rbp),%xmm4
movss  -0x50(%rbp),%xmm3
mulss  -0x48(%rbp),%xmm3
movd   %xmm3,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm3
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x64(%rbp),%xmm0
movss  -0x38(%rbp),%xmm1
mulss  -0x38(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x68(%rbp),%xmm0
movss  %xmm0,-0x4(%rbp)
movss  -0x4(%rbp),%xmm0
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<point_nearest_line>:
push   %r15
push   %r14
push   %rbx
sub    $0x10,%rsp
mov    %rcx,%rbx
mov    %rdx,%r15
mov    %rdi,%r14
movss  (%rsi),%xmm7
movss  0x4(%rsi),%xmm0
movss  0x8(%rcx),%xmm1
movss  0x8(%rsi),%xmm6
movss  (%rcx),%xmm2
movss  0x4(%rcx),%xmm3
movaps %xmm0,%xmm5
mulss  %xmm1,%xmm5
mulss  %xmm7,%xmm1
mulss  %xmm3,%xmm7
mulss  %xmm6,%xmm3
subss  %xmm3,%xmm5
mulss  %xmm2,%xmm6
subss  %xmm1,%xmm6
mulss  %xmm0,%xmm2
subss  %xmm2,%xmm7
movaps %xmm6,%xmm0
mulss  %xmm6,%xmm0
movaps %xmm5,%xmm1
mulss  %xmm5,%xmm1
addss  %xmm0,%xmm1
movaps %xmm7,%xmm0
mulss  %xmm7,%xmm0
addss  %xmm1,%xmm0
xorps  %xmm3,%xmm3
ucomiss %xmm3,%xmm0
jb     1190 <point_nearest_line+0x80>
sqrtss %xmm0,%xmm0
jmp    11bc <point_nearest_line+0xac>
movss  %xmm7,0xc(%rsp)
movss  %xmm6,0x8(%rsp)
movss  %xmm5,0x4(%rsp)
call   1030 <sqrt@plt>
xorps  %xmm3,%xmm3
movss  0x4(%rsp),%xmm5
movss  0x8(%rsp),%xmm6
movss  0xc(%rsp),%xmm7
xorps  %xmm1,%xmm1
cvtss2sd %xmm0,%xmm1
movsd  0xe35(%rip),%xmm2
ucomisd %xmm1,%xmm2
jae    1247 <point_nearest_line+0x137>
movss  (%r15),%xmm9
movss  0x4(%r15),%xmm8
subss  (%r14),%xmm9
subss  0x4(%r14),%xmm8
movss  0x8(%r15),%xmm10
subss  0x8(%r14),%xmm10
movss  (%rbx),%xmm3
movss  0x4(%rbx),%xmm4
movss  0x8(%rbx),%xmm2
movaps %xmm6,%xmm1
mulss  %xmm2,%xmm1
mulss  %xmm5,%xmm2
mulss  %xmm4,%xmm5
mulss  %xmm7,%xmm4
subss  %xmm1,%xmm4
mulss  %xmm9,%xmm4
mulss  %xmm3,%xmm7
subss  %xmm2,%xmm7
mulss  %xmm8,%xmm7
subss  %xmm7,%xmm4
mulss  %xmm6,%xmm3
subss  %xmm5,%xmm3
mulss  %xmm10,%xmm3
addss  %xmm4,%xmm3
mulss  %xmm0,%xmm0
divss  %xmm0,%xmm3
movaps %xmm3,%xmm0
add    $0x10,%rsp
pop    %rbx
pop    %r14
pop    %r15
ret

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

LLVM IR (-O2):
define float @point_nearest_line(float* nocapture %0, float* nocapture %1, float* nocapture %2, float* nocapture %3) {
%5 = getelementptr inbounds float, float* %1, i64 1
%6 = load float, float* %5
%7 = getelementptr inbounds float, float* %3, i64 2
%8 = load float, float* %7
%9 = getelementptr inbounds float, float* %1, i64 2
%10 = load float, float* %9
%11 = getelementptr inbounds float, float* %3, i64 1
%12 = load float, float* %11
%13 = fneg float %10
%14 = fmul float %12, %13
%15 = tail call float @llvm.fmuladd.f32(float %6, float %8, float %14)
%16 = load float, float* %1
%17 = fneg float %16
%18 = load float, float* %3
%19 = fmul float %10, %18
%20 = tail call float @llvm.fmuladd.f32(float %17, float %8, float %19)
%21 = fneg float %6
%22 = fmul float %18, %21
%23 = tail call float @llvm.fmuladd.f32(float %16, float %12, float %22)
%24 = fmul float %20, %20
%25 = tail call float @llvm.fmuladd.f32(float %15, float %15, float %24)
%26 = tail call float @llvm.fmuladd.f32(float %23, float %23, float %25)
%27 = tail call float @sqrt(float %26)
%28 = fpext float %27 to double
%29 = fcmp ugt double %28, 1.000000e-04
br i1 %29, label %30, label %61
30: ; preds = %4
%31 = load float, float* %2
%32 = load float, float* %0
%33 = fsub float %31, %32
%34 = getelementptr inbounds float, float* %2, i64 1
%35 = load float, float* %34
%36 = getelementptr inbounds float, float* %0, i64 1
%37 = load float, float* %36
%38 = fsub float %35, %37
%39 = getelementptr inbounds float, float* %2, i64 2
%40 = load float, float* %39
%41 = getelementptr inbounds float, float* %0, i64 2
%42 = load float, float* %41
%43 = fsub float %40, %42
%44 = load float, float* %3
%45 = load float, float* %11
%46 = load float, float* %7
%47 = fneg float %46
%48 = fmul float %20, %47
%49 = tail call float @llvm.fmuladd.f32(float %45, float %23, float %48)
%50 = fmul float %15, %47
%51 = tail call float @llvm.fmuladd.f32(float %44, float %23, float %50)
%52 = fneg float %38
%53 = fmul float %51, %52
%54 = tail call float @llvm.fmuladd.f32(float %33, float %49, float %53)
%55 = fneg float %45
%56 = fmul float %15, %55
%57 = tail call float @llvm.fmuladd.f32(float %44, float %20, float %56)
%58 = tail call float @llvm.fmuladd.f32(float %43, float %57, float %54)
%59 = fmul float %27, %27
%60 = fdiv float %58, %59
br label %61
61: ; preds = %4, %30
%62 = phi float [ %60, %30 ], [ 0.000000e+00, %4 ]
ret float %62
}