void provmeans(double *Xs, double *Ws, int NN, int n, double *sw, double *mn,
               double *cov) {
  double w, r;
  int i, j, k;
  double d[400];
  for (i = 0; i < n; i++) {
    w = *Ws;
    *sw += *Ws++;
    r = w / (*sw);
    for (j = 0; j < NN; j++) {
      d[j] = Xs[i * NN + j] - mn[j];
      mn[j] += d[j] * r;
    }
    for (j = 0; j < NN; j++)
      for (k = j; k < NN; k++)
        cov[j * NN + k] += d[j] * d[k] * (1 - r) * w;
  }
}


x86 assembly (clang, -O0):
<provmeans>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc50,%rsp
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    129f <provmeans+0x19f>
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x10(%rbp)
movsd  (%rax),%xmm0
mov    -0x20(%rbp),%rax
addsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
movsd  -0x30(%rbp),%xmm0
mov    -0x20(%rbp),%rax
divsd  (%rax),%xmm0
movsd  %xmm0,-0x38(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11f3 <provmeans+0xf3>
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x40(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movslq -0x40(%rbp),%rax
movsd  %xmm0,-0xcd0(%rbp,%rax,8)
ff ff
movslq -0x40(%rbp),%rax
movsd  -0xcd0(%rbp,%rax,8),%xmm0
ff ff
movsd  -0x38(%rbp),%xmm2
mov    -0x28(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    117d <provmeans+0x7d>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    128c <provmeans+0x18c>
mov    -0x40(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1279 <provmeans+0x179>
movslq -0x40(%rbp),%rax
movsd  -0xcd0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x44(%rbp),%rax
mulsd  -0xcd0(%rbp,%rax,8),%xmm0
ff ff
movsd  0xdc6(%rip),%xmm1
subsd  -0x38(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  -0x30(%rbp),%xmm2
mov    0x10(%rbp),%rax
mov    -0x40(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    120c <provmeans+0x10c>
jmp    127e <provmeans+0x17e>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    11fa <provmeans+0xfa>
jmp    1291 <provmeans+0x191>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    112c <provmeans+0x2c>
add    $0xc50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<provmeans>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xc98,%rsp
mov    %r8,-0x8(%rsp)
mov    %edx,-0x74(%rsp)
mov    %rdi,-0x68(%rsp)
test   %ecx,%ecx
jle    1580 <provmeans+0x480>
mov    0xcd0(%rsp),%rbx
movslq -0x74(%rsp),%r12
mov    %ecx,%eax
mov    %rax,-0x10(%rsp)
mov    %r12d,%ecx
lea    (%r9,%rcx,8),%rax
mov    %rax,-0x30(%rsp)
mov    %ecx,%eax
and    $0xfffffffe,%eax
mov    %rax,-0x38(%rsp)
add    $0xfffffffffffffffe,%rax
mov    %rax,-0x40(%rsp)
mov    %rax,%rdx
shr    %rdx
add    $0x1,%rdx
mov    %rdx,%rax
mov    %rdx,-0x48(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,-0x50(%rsp)
mov    %rcx,%rax
neg    %rax
mov    %rax,-0x18(%rsp)
mov    -0x68(%rsp),%rax
lea    0x10(%rax),%rdx
lea    0x0(,%r12,8),%r15
add    $0x8,%rax
lea    -0x1(%rcx),%rdi
mov    %rdi,-0x20(%rsp)
movsd  0xe59(%rip),%xmm8
lea    0x18(%rbx),%rdi
mov    %rdi,-0x28(%rsp)
lea    0x8(,%r12,8),%r14
xor    %edi,%edi
mov    %rdi,-0x60(%rsp)
mov    %r14,0x8(%rsp)
jmp    1204 <provmeans+0x104>
cs nopw 0x0(%rax,%rax,1)
mov    (%rsp),%rsi
add    $0x8,%rsi
mov    -0x60(%rsp),%rbp
add    $0x1,%rbp
mov    -0x58(%rsp),%rdx
add    %r15,%rdx
mov    -0x70(%rsp),%rax
add    %r15,%rax
mov    %rbp,%rdi
mov    %rbp,-0x60(%rsp)
cmp    -0x10(%rsp),%rbp
je     1580 <provmeans+0x480>
mov    %rax,-0x70(%rsp)
mov    %rdx,-0x58(%rsp)
mov    %rsi,(%rsp)
movsd  (%rsi),%xmm9
mov    -0x8(%rsp),%rax
movsd  (%rax),%xmm3
addsd  %xmm9,%xmm3
movsd  %xmm3,(%rax)
cmpl   $0x0,-0x74(%rsp)
jle    11d0 <provmeans+0xd0>
mov    -0x60(%rsp),%rdi
imul   %r12,%rdi
movapd %xmm9,%xmm2
divsd  %xmm3,%xmm2
cmpl   $0x1,-0x74(%rsp)
jne    1260 <provmeans+0x160>
xor    %esi,%esi
mov    -0x68(%rsp),%rbp
mov    -0x70(%rsp),%rax
jmp    1360 <provmeans+0x260>
nopw   0x0(%rax,%rax,1)
lea    (%rdi,%rcx,1),%rax
mov    -0x68(%rsp),%rbp
lea    0x0(,%rax,8),%rax
add    %rbp,%rax
cmp    %r9,%rax
jbe    1297 <provmeans+0x197>
lea    0x0(,%rdi,8),%rax
add    %rbp,%rax
cmp    -0x30(%rsp),%rax
jae    1297 <provmeans+0x197>
xor    %esi,%esi
mov    -0x70(%rsp),%rax
jmp    1360 <provmeans+0x260>
movapd %xmm2,%xmm3
unpcklpd %xmm2,%xmm3
cmpq   $0x0,-0x40(%rsp)
mov    -0x58(%rsp),%rax
je     156e <provmeans+0x46e>
mov    -0x50(%rsp),%rsi
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movupd -0x10(%rax,%rdx,8),%xmm4
movupd (%r9,%rdx,8),%xmm5
subpd  %xmm5,%xmm4
movapd %xmm4,0x10(%rsp,%rdx,8)
mulpd  %xmm3,%xmm4
addpd  %xmm5,%xmm4
movupd %xmm4,(%r9,%rdx,8)
movupd (%rax,%rdx,8),%xmm4
movupd 0x10(%r9,%rdx,8),%xmm5
subpd  %xmm5,%xmm4
movapd %xmm4,0x20(%rsp,%rdx,8)
mulpd  %xmm3,%xmm4
addpd  %xmm5,%xmm4
movupd %xmm4,0x10(%r9,%rdx,8)
add    $0x4,%rdx
add    $0xfffffffffffffffe,%rsi
jne    12c0 <provmeans+0x1c0>
testb  $0x1,-0x48(%rsp)
je     1342 <provmeans+0x242>
lea    (%rdx,%rdi,1),%rax
movupd 0x0(%rbp,%rax,8),%xmm4
movupd (%r9,%rdx,8),%xmm5
subpd  %xmm5,%xmm4
movapd %xmm4,0x10(%rsp,%rdx,8)
mulpd  %xmm3,%xmm4
addpd  %xmm5,%xmm4
movupd %xmm4,(%r9,%rdx,8)
mov    -0x38(%rsp),%rax
mov    %rax,%rsi
cmp    %rcx,%rax
mov    -0x70(%rsp),%rax
je     13f2 <provmeans+0x2f2>
nopl   0x0(%rax,%rax,1)
mov    %rsi,%rdx
test   $0x1,%cl
je     1396 <provmeans+0x296>
add    %rsi,%rdi
movsd  0x0(%rbp,%rdi,8),%xmm3
movsd  (%r9,%rsi,8),%xmm4
subsd  %xmm4,%xmm3
movsd  %xmm3,0x10(%rsp,%rsi,8)
mulsd  %xmm2,%xmm3
addsd  %xmm4,%xmm3
movsd  %xmm3,(%r9,%rsi,8)
mov    %rsi,%rdx
or     $0x1,%rdx
not    %rsi
cmp    -0x18(%rsp),%rsi
je     13f2 <provmeans+0x2f2>
movsd  -0x8(%rax,%rdx,8),%xmm3
movsd  (%r9,%rdx,8),%xmm4
subsd  %xmm4,%xmm3
movsd  %xmm3,0x10(%rsp,%rdx,8)
mulsd  %xmm2,%xmm3
addsd  %xmm4,%xmm3
movsd  %xmm3,(%r9,%rdx,8)
movsd  (%rax,%rdx,8),%xmm3
movsd  0x8(%r9,%rdx,8),%xmm4
subsd  %xmm4,%xmm3
movsd  %xmm3,0x18(%rsp,%rdx,8)
mulsd  %xmm2,%xmm3
addsd  %xmm4,%xmm3
movsd  %xmm3,0x8(%r9,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%rcx
jne    13a0 <provmeans+0x2a0>
cmpl   $0x0,-0x74(%rsp)
jle    11d0 <provmeans+0xd0>
movapd %xmm8,%xmm10
subsd  %xmm2,%xmm10
movapd %xmm10,%xmm2
unpcklpd %xmm10,%xmm2
movapd %xmm9,%xmm4
unpcklpd %xmm9,%xmm4
mov    %rbx,%r10
mov    -0x28(%rsp),%r11
lea    0x28(%rsp),%rdi
mov    -0x20(%rsp),%rbp
xor    %r8d,%r8d
jmp    145b <provmeans+0x35b>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r8
add    $0xffffffffffffffff,%rbp
add    $0x8,%rdi
add    %r14,%r11
add    %r15,%r10
cmp    %rcx,%r8
je     11d0 <provmeans+0xd0>
movsd  0x10(%rsp,%r8,8),%xmm5
mov    %r8,%rax
imul   %r12,%rax
movapd %xmm5,%xmm6
mulsd  %xmm5,%xmm6
mulsd  %xmm10,%xmm6
add    %r8,%rax
mulsd  %xmm9,%xmm6
addsd  (%rbx,%rax,8),%xmm6
movsd  %xmm6,(%rbx,%rax,8)
lea    0x1(%r8),%rdx
cmp    %rcx,%rdx
je     1440 <provmeans+0x340>
mov    %r8,%rsi
not    %rsi
add    %rcx,%rsi
cmp    $0x4,%rsi
jb     1540 <provmeans+0x440>
mov    %r15,%r14
mov    %r12,%r15
mov    %rbp,%r12
and    $0xfffffffffffffffc,%r12
mov    %rsi,%r13
and    $0xfffffffffffffffc,%r13
add    %r13,%rdx
movapd %xmm5,%xmm6
unpcklpd %xmm5,%xmm6
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nop
movupd -0x10(%rdi,%rax,8),%xmm7
movupd (%rdi,%rax,8),%xmm0
mulpd  %xmm6,%xmm7
mulpd  %xmm6,%xmm0
mulpd  %xmm2,%xmm7
mulpd  %xmm2,%xmm0
movupd -0x10(%r11,%rax,8),%xmm1
movupd (%r11,%rax,8),%xmm3
mulpd  %xmm4,%xmm7
addpd  %xmm1,%xmm7
mulpd  %xmm4,%xmm0
addpd  %xmm3,%xmm0
movupd %xmm7,-0x10(%r11,%rax,8)
movupd %xmm0,(%r11,%rax,8)
add    $0x4,%rax
cmp    %rax,%r12
jne    14d0 <provmeans+0x3d0>
cmp    %r13,%rsi
mov    %r15,%r12
mov    %r14,%r15
mov    0x8(%rsp),%r14
je     1440 <provmeans+0x340>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  0x10(%rsp,%rdx,8),%xmm0
mulsd  %xmm5,%xmm0
mulsd  %xmm10,%xmm0
mulsd  %xmm9,%xmm0
addsd  (%r10,%rdx,8),%xmm0
movsd  %xmm0,(%r10,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    1540 <provmeans+0x440>
jmp    1440 <provmeans+0x340>
xor    %edx,%edx
testb  $0x1,-0x48(%rsp)
jne    131a <provmeans+0x21a>
jmp    1342 <provmeans+0x242>
add    $0xc98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @provmeans(double* %0, double* %1, i32 %2, i32 %3, double* %4, double* %5, double* %6) {
%8 = alloca double*
%9 = alloca double*
%10 = alloca i32
%11 = alloca i32
%12 = alloca double*
%13 = alloca double*
%14 = alloca double*
%15 = alloca double
%16 = alloca double
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca [400 x double]
store double* %0, double** %8
store double* %1, double** %9
store i32 %2, i32* %10
store i32 %3, i32* %11
store double* %4, double** %12
store double* %5, double** %13
store double* %6, double** %14
store i32 0, i32* %17
br label %21
21: ; preds = %118, %7
%22 = load i32, i32* %17
%23 = load i32, i32* %11
%24 = icmp slt i32 %22, %23
br i1 %24, label %25, label %121
25: ; preds = %21
%26 = load double*, double** %9
%27 = load double, double* %26
store double %27, double* %15
%28 = load double*, double** %9
%29 = getelementptr inbounds double, double* %28, i32 1
store double* %29, double** %9
%30 = load double, double* %28
%31 = load double*, double** %12
%32 = load double, double* %31
%33 = fadd double %32, %30
store double %33, double* %31
%34 = load double, double* %15
%35 = load double*, double** %12
%36 = load double, double* %35
%37 = fdiv double %34, %36
store double %37, double* %16
store i32 0, i32* %18
br label %38
38: ; preds = %72, %25
%39 = load i32, i32* %18
%40 = load i32, i32* %10
%41 = icmp slt i32 %39, %40
br i1 %41, label %42, label %75
42: ; preds = %38
%43 = load double*, double** %8
%44 = load i32, i32* %17
%45 = load i32, i32* %10
%46 = mul nsw i32 %44, %45
%47 = load i32, i32* %18
%48 = add nsw i32 %46, %47
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds double, double* %43, i64 %49
%51 = load double, double* %50
%52 = load double*, double** %13
%53 = load i32, i32* %18
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds double, double* %52, i64 %54
%56 = load double, double* %55
%57 = fsub double %51, %56
%58 = load i32, i32* %18
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds [400 x double], [400 x double]* %20, i64 0, i64 %59
store double %57, double* %60
%61 = load i32, i32* %18
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds [400 x double], [400 x double]* %20, i64 0, i64 %62
%64 = load double, double* %63
%65 = load double, double* %16
%66 = load double*, double** %13
%67 = load i32, i32* %18
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds double, double* %66, i64 %68
%70 = load double, double* %69
%71 = call double @llvm.fmuladd.f64(double %64, double %65, double %70)
store double %71, double* %69
br label %72
72: ; preds = %42
%73 = load i32, i32* %18
%74 = add nsw i32 %73, 1
store i32 %74, i32* %18
br label %38
75: ; preds = %38
store i32 0, i32* %18
br label %76
76: ; preds = %114, %75
%77 = load i32, i32* %18
%78 = load i32, i32* %10
%79 = icmp slt i32 %77, %78
br i1 %79, label %80, label %117
80: ; preds = %76
%81 = load i32, i32* %18
store i32 %81, i32* %19
br label %82
82: ; preds = %110, %80
%83 = load i32, i32* %19
%84 = load i32, i32* %10
%85 = icmp slt i32 %83, %84
br i1 %85, label %86, label %113
86: ; preds = %82
%87 = load i32, i32* %18
%88 = sext i32 %87 to i64
%89 = getelementptr inbounds [400 x double], [400 x double]* %20, i64 0, i64 %88
%90 = load double, double* %89
%91 = load i32, i32* %19
%92 = sext i32 %91 to i64
%93 = getelementptr inbounds [400 x double], [400 x double]* %20, i64 0, i64 %92
%94 = load double, double* %93
%95 = fmul double %90, %94
%96 = load double, double* %16
%97 = fsub double 1.000000e+00, %96
%98 = fmul double %95, %97
%99 = load double, double* %15
%100 = load double*, double** %14
%101 = load i32, i32* %18
%102 = load i32, i32* %10
%103 = mul nsw i32 %101, %102
%104 = load i32, i32* %19
%105 = add nsw i32 %103, %104
%106 = sext i32 %105 to i64
%107 = getelementptr inbounds double, double* %100, i64 %106
%108 = load double, double* %107
%109 = call double @llvm.fmuladd.f64(double %98, double %99, double %108)
store double %109, double* %107
br label %110
110: ; preds = %86
%111 = load i32, i32* %19
%112 = add nsw i32 %111, 1
store i32 %112, i32* %19
br label %82
113: ; preds = %82
br label %114
114: ; preds = %113
%115 = load i32, i32* %18
%116 = add nsw i32 %115, 1
store i32 %116, i32* %18
br label %76
117: ; preds = %76
br label %118
118: ; preds = %117
%119 = load i32, i32* %17
%120 = add nsw i32 %119, 1
store i32 %120, i32* %17
br label %21
121: ; preds = %21
ret void
}

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