#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 */
double sqrt(double);
void logarithmic_gradient(double *pars, double *r, double *grad) {
  double x, y, z, _r, _r2, ax, ay, az, fac;
  x = pars[5] * r[0] + pars[6] * r[1] + pars[7] * r[2];
  y = pars[8] * r[0] + pars[9] * r[1] + pars[10] * r[2];
  z = pars[11] * r[0] + pars[12] * r[1] + pars[13] * r[2];
  _r2 = x * x + y * y + z * z;
  _r = sqrt(_r2);
  fac = pars[0] * pars[0] /
        (pars[1] * pars[1] + x * x / (pars[2] * pars[2]) +
         y * y / (pars[3] * pars[3]) + z * z / (pars[4] * pars[4]));
  ax = fac * x / (pars[2] * pars[2]);
  ay = fac * y / (pars[3] * pars[3]);
  az = fac * z / (pars[4] * pars[4]);
  grad[0] = pars[5] * ax + pars[8] * ay + pars[11] * az;
  grad[1] = pars[6] * ax + pars[9] * ay + pars[12] * az;
  grad[2] = pars[7] * ax + pars[10] * ay + pars[13] * az;
}


x86 assembly (clang, -O0):
<logarithmic_gradient>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x30(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x38(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x40(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x48(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x50(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x28(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x58(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x60(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x68(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x30(%rbp)
movsd  -0x20(%rbp),%xmm1
movsd  -0x20(%rbp),%xmm2
movsd  -0x28(%rbp),%xmm0
mulsd  -0x28(%rbp),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x30(%rbp),%xmm0
movsd  -0x30(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x40(%rbp),%xmm0
call   1030 <sqrt@plt>
movsd  %xmm0,-0x38(%rbp)
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x8(%rbp),%rax
mulsd  (%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm3
movsd  -0x20(%rbp),%xmm2
mulsd  -0x20(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm4
mov    -0x8(%rbp),%rax
mulsd  0x10(%rax),%xmm4
divsd  %xmm4,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
movsd  -0x28(%rbp),%xmm2
mulsd  -0x28(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm3
mov    -0x8(%rbp),%rax
mulsd  0x18(%rax),%xmm3
divsd  %xmm3,%xmm2
addsd  %xmm2,%xmm1
movsd  -0x30(%rbp),%xmm2
mulsd  -0x30(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm3
mov    -0x8(%rbp),%rax
mulsd  0x20(%rax),%xmm3
divsd  %xmm3,%xmm2
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
mulsd  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulsd  0x10(%rax),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x60(%rbp),%xmm0
mulsd  -0x28(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulsd  0x18(%rax),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x60(%rbp),%xmm0
mulsd  -0x30(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulsd  0x20(%rax),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm1
movsd  -0x48(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x40(%rax),%xmm0
mulsd  -0x50(%rbp),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x58(%rax),%xmm0
movsd  -0x58(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
movsd  0x30(%rax),%xmm1
movsd  -0x48(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x48(%rax),%xmm0
mulsd  -0x50(%rbp),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x60(%rax),%xmm0
movsd  -0x58(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
movsd  0x38(%rax),%xmm1
movsd  -0x48(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x50(%rax),%xmm0
mulsd  -0x50(%rbp),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x68(%rax),%xmm0
movsd  -0x58(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x10(%rax)
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<logarithmic_gradient>:
movsd  0x28(%rdi),%xmm9
movsd  (%rsi),%xmm3
movsd  0x8(%rsi),%xmm7
movsd  0x30(%rdi),%xmm0
mulsd  %xmm7,%xmm0
movapd %xmm9,%xmm2
mulsd  %xmm3,%xmm2
addsd  %xmm0,%xmm2
movsd  0x10(%rsi),%xmm5
movsd  0x38(%rdi),%xmm1
mulsd  %xmm5,%xmm1
addsd  %xmm2,%xmm1
movsd  0x40(%rdi),%xmm8
movsd  0x48(%rdi),%xmm2
mulsd  %xmm7,%xmm2
movapd %xmm8,%xmm6
mulsd  %xmm3,%xmm6
addsd  %xmm2,%xmm6
movsd  0x50(%rdi),%xmm2
mulsd  %xmm5,%xmm2
addsd  %xmm6,%xmm2
movsd  0x58(%rdi),%xmm10
mulsd  0x60(%rdi),%xmm7
mulsd  %xmm10,%xmm3
addsd  %xmm7,%xmm3
mulsd  0x68(%rdi),%xmm5
addsd  %xmm3,%xmm5
movapd %xmm2,%xmm7
mulsd  %xmm2,%xmm7
movsd  (%rdi),%xmm3
movsd  0x8(%rdi),%xmm4
mulsd  %xmm3,%xmm3
movapd %xmm1,%xmm0
mulsd  %xmm1,%xmm0
movsd  0x10(%rdi),%xmm11
mulsd  %xmm11,%xmm11
divsd  %xmm11,%xmm0
mulsd  %xmm4,%xmm4
addsd  %xmm0,%xmm4
movsd  0x18(%rdi),%xmm0
mulsd  %xmm0,%xmm0
divsd  %xmm0,%xmm7
addsd  %xmm4,%xmm7
movapd %xmm5,%xmm4
mulsd  %xmm5,%xmm4
movsd  0x20(%rdi),%xmm6
mulsd  %xmm6,%xmm6
divsd  %xmm6,%xmm4
addsd  %xmm7,%xmm4
divsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm1
divsd  %xmm11,%xmm1
mulsd  %xmm3,%xmm2
divsd  %xmm0,%xmm2
mulsd  %xmm5,%xmm3
divsd  %xmm6,%xmm3
mulsd  %xmm2,%xmm8
mulsd  %xmm1,%xmm9
addsd  %xmm8,%xmm9
mulsd  %xmm3,%xmm10
addsd  %xmm9,%xmm10
movsd  %xmm10,(%rdx)
movsd  0x48(%rdi),%xmm0
mulsd  %xmm2,%xmm0
movsd  0x30(%rdi),%xmm4
mulsd  %xmm1,%xmm4
addsd  %xmm0,%xmm4
movsd  0x60(%rdi),%xmm0
mulsd  %xmm3,%xmm0
addsd  %xmm4,%xmm0
movsd  %xmm0,0x8(%rdx)
mulsd  0x50(%rdi),%xmm2
mulsd  0x38(%rdi),%xmm1
addsd  %xmm2,%xmm1
mulsd  0x68(%rdi),%xmm3
addsd  %xmm1,%xmm3
movsd  %xmm3,0x10(%rdx)
ret

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

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