#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 pow(double, int);
void enthalpy_3(double HL[], double HV[], double x[][3], double y[][3],
                double T[], double MW[], double HVAP[], double HCAPLa[],
                double HCAPLb[], double HCAPVa[], double HCAPVb[]) {
  int i, j;
  double mw[3], hvap[3], hcapla[3], hcaplb[3], hcapva[3], hcapvb[3];
  double hcapl[3], hcapv[3], HLL, HVV;
  for (i = 4; i < 7; i++) {
    mw[i - 4] = MW[i];
    hvap[i - 4] = HVAP[i];
    hcapla[i - 4] = HCAPLa[i];
    hcaplb[i - 4] = HCAPLb[i];
    hcapva[i - 4] = HCAPVa[i];
    hcapvb[i - 4] = HCAPVb[i];
  };
  HLL = 0.;
  HVV = 0.;
  for (j = 0; j < 3; j++) {
    hcapl[j] = (hcapla[j] * T[0] + 0.5 * hcaplb[j] * pow(T[0], 2)) * mw[j];
    hcapv[j] =
        (hcapva[j] * T[0] + 0.5 * hcapvb[j] * pow(T[0], 2)) * mw[j] + hvap[j];
    HLL += x[0][j] * hcapl[j];
    HVV += y[0][j] * hcapv[j];
  };
  HL[0] = HLL;
  HV[0] = HVV;
}


x86 assembly (clang, -O0):
<enthalpy_3>:
push   %rbp
mov    %rsp,%rbp
sub    $0x170,%rsp
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movl   $0x4,-0x34(%rbp)
cmpl   $0x7,-0x34(%rbp)
jge    1214 <enthalpy_3+0x104>
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x34(%rbp),%eax
sub    $0x4,%eax
cltq
movsd  %xmm0,-0x50(%rbp,%rax,8)
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x34(%rbp),%eax
sub    $0x4,%eax
cltq
movsd  %xmm0,-0x70(%rbp,%rax,8)
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x34(%rbp),%eax
sub    $0x4,%eax
cltq
movsd  %xmm0,-0x90(%rbp,%rax,8)
ff ff
mov    0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x34(%rbp),%eax
sub    $0x4,%eax
cltq
movsd  %xmm0,-0xb0(%rbp,%rax,8)
ff ff
mov    0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x34(%rbp),%eax
sub    $0x4,%eax
cltq
movsd  %xmm0,-0xd0(%rbp,%rax,8)
ff ff
mov    0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x34(%rbp),%eax
sub    $0x4,%eax
cltq
movsd  %xmm0,-0xf0(%rbp,%rax,8)
ff ff
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    114e <enthalpy_3+0x3e>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
movl   $0x0,-0x38(%rbp)
cmpl   $0x3,-0x38(%rbp)
jge    13e3 <enthalpy_3+0x2d3>
movslq -0x38(%rbp),%rax
movsd  -0x90(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x160(%rbp)
ff
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x168(%rbp)
ff
movslq -0x38(%rbp),%rax
movsd  0xd94(%rip),%xmm0
mulsd  -0xb0(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x170(%rbp)
ff
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm0
mov    $0x2,%edi
call   1030 <pow@plt>
movsd  -0x170(%rbp),%xmm1
ff
movsd  -0x168(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0x160(%rbp),%xmm0
ff
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x38(%rbp),%rax
mulsd  -0x50(%rbp,%rax,8),%xmm0
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x110(%rbp,%rax,8)
ff ff
movslq -0x38(%rbp),%rax
movsd  -0xd0(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x148(%rbp)
ff
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
movslq -0x38(%rbp),%rax
movsd  0xd02(%rip),%xmm0
mulsd  -0xf0(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x158(%rbp)
ff
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm0
mov    $0x2,%edi
call   1030 <pow@plt>
movsd  -0x158(%rbp),%xmm1
ff
movsd  -0x150(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0x148(%rbp),%xmm0
ff
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x38(%rbp),%rax
movsd  -0x50(%rbp,%rax,8),%xmm2
movslq -0x38(%rbp),%rax
movsd  -0x70(%rbp,%rax,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x130(%rbp,%rax,8)
ff ff
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x38(%rbp),%rax
movsd  -0x110(%rbp,%rax,8),%xmm2
ff ff
movsd  -0x138(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x38(%rbp),%rax
movsd  -0x130(%rbp,%rax,8),%xmm2
ff ff
movsd  -0x140(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1231 <enthalpy_3+0x121>
movsd  -0x138(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x140(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,(%rax)
add    $0x170,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<enthalpy_3>:
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x90,%rsp
mov    %r8,%rbx
mov    %rcx,%r12
mov    %rdx,%r13
mov    %rsi,%r14
mov    %rdi,%r15
mov    0xe0(%rsp),%rax
mov    0xd0(%rsp),%rdx
mov    0xd8(%rsp),%rcx
mov    0xc8(%rsp),%rsi
mov    0xc0(%rsp),%rdi
movsd  0x20(%r9),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x28(%r9),%xmm0
movsd  %xmm0,0x38(%rsp)
movsd  0x30(%r9),%xmm0
movsd  %xmm0,0x40(%rsp)
movsd  0x20(%rdi),%xmm0
movsd  %xmm0,0x58(%rsp)
movsd  0x28(%rdi),%xmm0
movsd  %xmm0,0x70(%rsp)
movsd  0x30(%rdi),%xmm0
movsd  %xmm0,0x88(%rsp)
movsd  0x28(%rsi),%xmm0
movsd  %xmm0,0x18(%rsp)
movsd  0x30(%rsi),%xmm0
movsd  %xmm0,0x30(%rsp)
movsd  (%r8),%xmm0
movsd  0xe3e(%rip),%xmm1
movsd  0x20(%rdx),%xmm2
mulsd  %xmm1,%xmm2
movsd  %xmm2,0x10(%rsp)
movsd  0x20(%rsi),%xmm3
movsd  0x20(%rax),%xmm2
mulsd  %xmm1,%xmm2
movsd  %xmm2,0x48(%rsp)
movsd  0x28(%rdx),%xmm2
mulsd  %xmm1,%xmm2
movsd  %xmm2,0x50(%rsp)
movsd  0x28(%rax),%xmm2
mulsd  %xmm1,%xmm2
movsd  %xmm2,0x60(%rsp)
movsd  0x30(%rdx),%xmm2
mulsd  %xmm1,%xmm2
movsd  %xmm2,0x68(%rsp)
mulsd  0x30(%rax),%xmm1
movsd  %xmm1,0x80(%rsp)
mulsd  %xmm0,%xmm3
movsd  %xmm3,0x20(%rsp)
movsd  0x20(%rcx),%xmm1
movsd  %xmm1,(%rsp)
movsd  0x28(%rcx),%xmm1
movsd  %xmm1,0x28(%rsp)
movsd  0x30(%rcx),%xmm1
movsd  %xmm1,0x78(%rsp)
mov    $0x2,%edi
call   1030 <pow@plt>
mulsd  0x10(%rsp),%xmm0
addsd  0x20(%rsp),%xmm0
mulsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  (%rbx),%xmm0
movsd  %xmm0,0x20(%rsp)
mov    $0x2,%edi
call   1030 <pow@plt>
mulsd  0x48(%rsp),%xmm0
movsd  (%rsp),%xmm1
mulsd  0x20(%rsp),%xmm1
addsd  %xmm0,%xmm1
mulsd  0x8(%rsp),%xmm1
addsd  0x58(%rsp),%xmm1
movsd  0x10(%rsp),%xmm2
mulsd  0x0(%r13),%xmm2
xorpd  %xmm0,%xmm0
addsd  %xmm0,%xmm2
movsd  %xmm2,0x10(%rsp)
mulsd  (%r12),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rsp)
movsd  (%rbx),%xmm0
movsd  %xmm0,0x8(%rsp)
mov    $0x2,%edi
call   1030 <pow@plt>
mulsd  0x50(%rsp),%xmm0
movsd  0x18(%rsp),%xmm1
mulsd  0x8(%rsp),%xmm1
addsd  %xmm0,%xmm1
mulsd  0x38(%rsp),%xmm1
movsd  %xmm1,0x18(%rsp)
movsd  (%rbx),%xmm0
movsd  %xmm0,0x8(%rsp)
mov    $0x2,%edi
call   1030 <pow@plt>
mulsd  0x60(%rsp),%xmm0
movsd  0x28(%rsp),%xmm1
mulsd  0x8(%rsp),%xmm1
addsd  %xmm0,%xmm1
mulsd  0x38(%rsp),%xmm1
addsd  0x70(%rsp),%xmm1
movsd  0x18(%rsp),%xmm0
mulsd  0x8(%r13),%xmm0
addsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x18(%rsp)
mulsd  0x8(%r12),%xmm1
addsd  (%rsp),%xmm1
movsd  %xmm1,0x28(%rsp)
movsd  (%rbx),%xmm0
movsd  %xmm0,(%rsp)
mov    $0x2,%edi
call   1030 <pow@plt>
mulsd  0x68(%rsp),%xmm0
movsd  0x30(%rsp),%xmm1
mulsd  (%rsp),%xmm1
addsd  %xmm0,%xmm1
mulsd  0x40(%rsp),%xmm1
movsd  %xmm1,0x30(%rsp)
movsd  (%rbx),%xmm0
movsd  %xmm0,(%rsp)
mov    $0x2,%edi
call   1030 <pow@plt>
mulsd  0x80(%rsp),%xmm0
movsd  0x78(%rsp),%xmm1
mulsd  (%rsp),%xmm1
addsd  %xmm0,%xmm1
mulsd  0x40(%rsp),%xmm1
addsd  0x88(%rsp),%xmm1
movsd  0x30(%rsp),%xmm0
mulsd  0x10(%r13),%xmm0
mulsd  0x10(%r12),%xmm1
addsd  0x18(%rsp),%xmm0
addsd  0x28(%rsp),%xmm1
movsd  %xmm0,(%r15)
movsd  %xmm1,(%r14)
add    $0x90,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
ret

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

LLVM IR (-O2):
define void @enthalpy_3(double* nocapture writeonly %0, double* nocapture writeonly %1, [3 x double]* nocapture %2, [3 x double]* nocapture %3, double* nocapture %4, double* nocapture %5, double* nocapture %6, double* nocapture %7, double* nocapture %8, double* nocapture %9, double* nocapture %10) {
%12 = getelementptr inbounds double, double* %5, i64 4
%13 = load double, double* %12
%14 = getelementptr inbounds double, double* %5, i64 5
%15 = load double, double* %14
%16 = getelementptr inbounds double, double* %5, i64 6
%17 = load double, double* %16
%18 = getelementptr inbounds double, double* %6, i64 4
%19 = load double, double* %18
%20 = getelementptr inbounds double, double* %6, i64 5
%21 = load double, double* %20
%22 = getelementptr inbounds double, double* %6, i64 6
%23 = load double, double* %22
%24 = getelementptr inbounds double, double* %7, i64 4
%25 = load double, double* %24
%26 = getelementptr inbounds double, double* %7, i64 5
%27 = load double, double* %26
%28 = getelementptr inbounds double, double* %7, i64 6
%29 = load double, double* %28
%30 = getelementptr inbounds double, double* %8, i64 4
%31 = load double, double* %30
%32 = getelementptr inbounds double, double* %8, i64 5
%33 = load double, double* %32
%34 = getelementptr inbounds double, double* %8, i64 6
%35 = load double, double* %34
%36 = getelementptr inbounds double, double* %9, i64 4
%37 = load double, double* %36
%38 = getelementptr inbounds double, double* %9, i64 5
%39 = load double, double* %38
%40 = getelementptr inbounds double, double* %9, i64 6
%41 = load double, double* %40
%42 = getelementptr inbounds double, double* %10, i64 4
%43 = load double, double* %42
%44 = getelementptr inbounds double, double* %10, i64 5
%45 = load double, double* %44
%46 = getelementptr inbounds double, double* %10, i64 6
%47 = load double, double* %46
%48 = load double, double* %4
%49 = fmul double %31, 5.000000e-01
%50 = tail call double @pow(double %48, i32 2)
%51 = fmul double %49, %50
%52 = tail call double @llvm.fmuladd.f64(double %25, double %48, double %51)
%53 = fmul double %13, %52
%54 = load double, double* %4
%55 = fmul double %43, 5.000000e-01
%56 = tail call double @pow(double %54, i32 2)
%57 = fmul double %55, %56
%58 = tail call double @llvm.fmuladd.f64(double %37, double %54, double %57)
%59 = tail call double @llvm.fmuladd.f64(double %58, double %13, double %19)
%60 = getelementptr inbounds [3 x double], [3 x double]* %2, i64 0, i64 0
%61 = load double, double* %60
%62 = tail call double @llvm.fmuladd.f64(double %61, double %53, double 0.000000e+00)
%63 = getelementptr inbounds [3 x double], [3 x double]* %3, i64 0, i64 0
%64 = load double, double* %63
%65 = tail call double @llvm.fmuladd.f64(double %64, double %59, double 0.000000e+00)
%66 = load double, double* %4
%67 = fmul double %33, 5.000000e-01
%68 = tail call double @pow(double %66, i32 2)
%69 = fmul double %67, %68
%70 = tail call double @llvm.fmuladd.f64(double %27, double %66, double %69)
%71 = fmul double %15, %70
%72 = load double, double* %4
%73 = fmul double %45, 5.000000e-01
%74 = tail call double @pow(double %72, i32 2)
%75 = fmul double %73, %74
%76 = tail call double @llvm.fmuladd.f64(double %39, double %72, double %75)
%77 = tail call double @llvm.fmuladd.f64(double %76, double %15, double %21)
%78 = getelementptr inbounds [3 x double], [3 x double]* %2, i64 0, i64 1
%79 = load double, double* %78
%80 = tail call double @llvm.fmuladd.f64(double %79, double %71, double %62)
%81 = getelementptr inbounds [3 x double], [3 x double]* %3, i64 0, i64 1
%82 = load double, double* %81
%83 = tail call double @llvm.fmuladd.f64(double %82, double %77, double %65)
%84 = load double, double* %4
%85 = fmul double %35, 5.000000e-01
%86 = tail call double @pow(double %84, i32 2)
%87 = fmul double %85, %86
%88 = tail call double @llvm.fmuladd.f64(double %29, double %84, double %87)
%89 = fmul double %17, %88
%90 = load double, double* %4
%91 = fmul double %47, 5.000000e-01
%92 = tail call double @pow(double %90, i32 2)
%93 = fmul double %91, %92
%94 = tail call double @llvm.fmuladd.f64(double %41, double %90, double %93)
%95 = tail call double @llvm.fmuladd.f64(double %94, double %17, double %23)
%96 = getelementptr inbounds [3 x double], [3 x double]* %2, i64 0, i64 2
%97 = load double, double* %96
%98 = tail call double @llvm.fmuladd.f64(double %97, double %89, double %80)
%99 = getelementptr inbounds [3 x double], [3 x double]* %3, i64 0, i64 2
%100 = load double, double* %99
%101 = tail call double @llvm.fmuladd.f64(double %100, double %95, double %83)
store double %98, double* %0
store double %101, double* %1
ret void
}