double filt(double u, double par[], double c[10][10], double x[10][4]) {
  double gg, gg1, gg2, den, u0, xn2cn1;
  double xn[4];
  int n, i;
  double y = u;
  for (n = 0; n < 10; n++) {
    gg = 2 * par[n];
    gg1 = par[n] + 1;
    gg2 = par[n] - 1;
    den = gg1 - gg2 * c[n][9];
    u0 = (gg2 * x[n][0] + 2 * y) / den;
    y = (gg * x[n][0] + (gg1 * c[n][9] - gg2) * y) / den;
    xn2cn1 = x[n][2] * c[n][1];
    xn[0] = x[n][0] * c[n][0] - x[n][1] + xn2cn1 + c[n][2] * u0;
    xn[1] = x[n][0] * c[n][4] + x[n][2] + c[n][3] * u0;
    xn[2] = x[n][0] * c[n][6] + xn2cn1 - x[n][3] + u0 * c[n][5];
    xn[3] = x[n][0] * c[n][8] + u0 * c[n][7];
    for (i = 0; i < 4; i++)
      x[n][i] = xn[i];
  }
  return y;
}


x86 assembly (clang, -O0):
<filt>:
push   %rbp
mov    %rsp,%rbp
movsd  %xmm0,-0x8(%rbp)
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
movsd  -0x8(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movl   $0x0,-0x74(%rbp)
cmpl   $0xa,-0x74(%rbp)
jge    1490 <filt+0x390>
mov    -0x10(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  0xec0(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  0xeae(%rip),%xmm0
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0xe8f(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x30(%rbp),%xmm1
movsd  -0x38(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x74(%rbp),%rcx
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movsd  0x48(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x38(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x74(%rbp),%rcx
shl    $0x5,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm2
movsd  0xe1c(%rip),%xmm1
mulsd  -0x80(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x28(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x74(%rbp),%rcx
shl    $0x5,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm2
movsd  -0x30(%rbp),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x74(%rbp),%rcx
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movsd  0x48(%rax),%xmm4
movsd  -0x38(%rbp),%xmm3
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm1
addsd  %xmm3,%xmm1
mulsd  -0x80(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x74(%rbp),%rcx
shl    $0x5,%rcx
add    %rcx,%rax
movsd  0x10(%rax),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x74(%rbp),%rcx
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
mulsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x74(%rbp),%rcx
shl    $0x5,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x74(%rbp),%rcx
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm2
mov    -0x20(%rbp),%rax
movslq -0x74(%rbp),%rcx
shl    $0x5,%rcx
add    %rcx,%rax
movsd  0x8(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
addsd  -0x50(%rbp),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x74(%rbp),%rcx
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movsd  0x10(%rax),%xmm0
movsd  -0x48(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x74(%rbp),%rcx
shl    $0x5,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x74(%rbp),%rcx
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movsd  0x20(%rax),%xmm2
mov    -0x20(%rbp),%rax
movslq -0x74(%rbp),%rcx
shl    $0x5,%rcx
add    %rcx,%rax
movsd  0x10(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
movslq -0x74(%rbp),%rcx
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movsd  0x18(%rax),%xmm0
movsd  -0x48(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x74(%rbp),%rcx
shl    $0x5,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x74(%rbp),%rcx
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movsd  0x30(%rax),%xmm2
movsd  -0x50(%rbp),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x20(%rbp),%rax
movslq -0x74(%rbp),%rcx
shl    $0x5,%rcx
add    %rcx,%rax
subsd  0x18(%rax),%xmm1
movsd  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x74(%rbp),%rcx
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movsd  0x28(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x74(%rbp),%rcx
shl    $0x5,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x74(%rbp),%rcx
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movsd  0x40(%rax),%xmm2
movsd  -0x48(%rbp),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x74(%rbp),%rcx
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
mulsd  0x38(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0x78(%rbp)
cmpl   $0x4,-0x78(%rbp)
jge    147d <filt+0x37d>
movslq -0x78(%rbp),%rax
movsd  -0x70(%rbp,%rax,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x74(%rbp),%rcx
shl    $0x5,%rcx
add    %rcx,%rax
movslq -0x78(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    1443 <filt+0x343>
jmp    1482 <filt+0x382>
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    1126 <filt+0x26>
movsd  -0x80(%rbp),%xmm0
pop    %rbp
ret

x86 assembly (clang, -O2):
<filt>:
add    $0x48,%rsi
xor    %eax,%eax
movsd  0xef1(%rip),%xmm8
movsd  0xef0(%rip),%xmm9
nopl   0x0(%rax,%rax,1)
movsd  (%rdi,%rax,1),%xmm6
movapd %xmm6,%xmm3
addsd  %xmm6,%xmm3
movapd %xmm6,%xmm7
addsd  %xmm8,%xmm7
addsd  %xmm9,%xmm6
movsd  (%rsi),%xmm1
movapd %xmm7,%xmm4
movapd %xmm6,%xmm5
mulsd  %xmm1,%xmm7
subsd  %xmm6,%xmm7
mulsd  %xmm1,%xmm6
subsd  %xmm6,%xmm4
mulsd  %xmm0,%xmm7
movapd %xmm0,%xmm1
addsd  %xmm0,%xmm1
movsd  (%rdx,%rax,4),%xmm0
movsd  0x10(%rdx,%rax,4),%xmm6
mulsd  %xmm0,%xmm5
addsd  %xmm1,%xmm5
divsd  %xmm4,%xmm5
mulsd  %xmm0,%xmm3
addsd  %xmm7,%xmm3
movsd  -0x40(%rsi),%xmm1
mulsd  %xmm6,%xmm1
movsd  -0x48(%rsi),%xmm7
mulsd  %xmm0,%xmm7
subsd  0x8(%rdx,%rax,4),%xmm7
addsd  %xmm1,%xmm7
movsd  -0x28(%rsi),%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm6,%xmm2
unpcklpd %xmm2,%xmm7
movupd -0x38(%rsi),%xmm2
movapd %xmm5,%xmm6
unpcklpd %xmm5,%xmm6
mulpd  %xmm2,%xmm6
movsd  -0x18(%rsi),%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm1,%xmm2
subsd  0x18(%rdx,%rax,4),%xmm2
addpd  %xmm7,%xmm6
movsd  -0x20(%rsi),%xmm1
mulsd  %xmm5,%xmm1
addsd  %xmm2,%xmm1
mulsd  -0x10(%rsi),%xmm5
mulsd  -0x8(%rsi),%xmm0
addsd  %xmm5,%xmm0
movupd %xmm6,(%rdx,%rax,4)
movsd  %xmm1,0x10(%rdx,%rax,4)
movsd  %xmm0,0x18(%rdx,%rax,4)
movapd %xmm3,%xmm0
divsd  %xmm4,%xmm0
add    $0x8,%rax
add    $0x50,%rsi
cmp    $0x50,%rax
jne    1120 <filt+0x20>
ret

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

LLVM IR (-O2):
define double @filt(double %0, double* nocapture %1, [10 x double]* nocapture %2, [4 x double]* nocapture %3) {
br label %5
5: ; preds = %4, %5
%6 = phi i64 [ 0, %4 ], [ %67, %5 ]
%7 = phi double [ %0, %4 ], [ %66, %5 ]
%8 = getelementptr [4 x double], [4 x double]* %3, i64 %6, i64 0
%9 = getelementptr inbounds double, double* %1, i64 %6
%10 = load double, double* %9
%11 = fmul double %10, 2.000000e+00
%12 = fadd double %10, 1.000000e+00
%13 = fadd double %10, -1.000000e+00
%14 = getelementptr inbounds [10 x double], [10 x double]* %2, i64 %6, i64 9
%15 = load double, double* %14
%16 = fneg double %13
%17 = tail call double @llvm.fmuladd.f64(double %16, double %15, double %12)
%18 = load double, double* %8
%19 = fmul double %7, 2.000000e+00
%20 = tail call double @llvm.fmuladd.f64(double %13, double %18, double %19)
%21 = fdiv double %20, %17
%22 = tail call double @llvm.fmuladd.f64(double %12, double %15, double %16)
%23 = fmul double %7, %22
%24 = tail call double @llvm.fmuladd.f64(double %11, double %18, double %23)
%25 = getelementptr inbounds [4 x double], [4 x double]* %3, i64 %6, i64 2
%26 = load double, double* %25
%27 = getelementptr inbounds [10 x double], [10 x double]* %2, i64 %6, i64 1
%28 = load double, double* %27
%29 = fmul double %26, %28
%30 = getelementptr inbounds [10 x double], [10 x double]* %2, i64 %6, i64 0
%31 = load double, double* %30
%32 = getelementptr inbounds [4 x double], [4 x double]* %3, i64 %6, i64 1
%33 = load double, double* %32
%34 = fneg double %33
%35 = tail call double @llvm.fmuladd.f64(double %18, double %31, double %34)
%36 = fadd double %29, %35
%37 = getelementptr inbounds [10 x double], [10 x double]* %2, i64 %6, i64 2
%38 = getelementptr inbounds [10 x double], [10 x double]* %2, i64 %6, i64 4
%39 = load double, double* %38
%40 = tail call double @llvm.fmuladd.f64(double %18, double %39, double %26)
%41 = bitcast double* %37 to <2 x double>*
%42 = load <2 x double>, <2 x double>* %41
%43 = insertelement <2 x double> poison, double %21, i64 0
%44 = shufflevector <2 x double> %43, <2 x double> poison, <2 x i32> zeroinitializer
%45 = insertelement <2 x double> poison, double %36, i64 0
%46 = insertelement <2 x double> %45, double %40, i64 1
%47 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %42, <2 x double> %44, <2 x double> %46)
%48 = getelementptr inbounds [10 x double], [10 x double]* %2, i64 %6, i64 6
%49 = load double, double* %48
%50 = tail call double @llvm.fmuladd.f64(double %18, double %49, double %29)
%51 = getelementptr inbounds [4 x double], [4 x double]* %3, i64 %6, i64 3
%52 = load double, double* %51
%53 = fsub double %50, %52
%54 = getelementptr inbounds [10 x double], [10 x double]* %2, i64 %6, i64 5
%55 = load double, double* %54
%56 = tail call double @llvm.fmuladd.f64(double %21, double %55, double %53)
%57 = getelementptr inbounds [10 x double], [10 x double]* %2, i64 %6, i64 8
%58 = load double, double* %57
%59 = getelementptr inbounds [10 x double], [10 x double]* %2, i64 %6, i64 7
%60 = load double, double* %59
%61 = fmul double %21, %60
%62 = tail call double @llvm.fmuladd.f64(double %18, double %58, double %61)
%63 = bitcast double* %8 to <2 x double>*
store <2 x double> %47, <2 x double>* %63
%64 = getelementptr [4 x double], [4 x double]* %3, i64 %6, i64 2
store double %56, double* %64
%65 = getelementptr [4 x double], [4 x double]* %3, i64 %6, i64 3
store double %62, double* %65
%66 = fdiv double %24, %17
%67 = add nuw nsw i64 %6, 1
%68 = icmp eq i64 %67, 10
br i1 %68, label %69, label %5
69: ; preds = %5
ret double %66
}