void calc_mean_and_covariance2(float weights[21][21],
                               float velocities[21][21][2], int weighted_size,
                               float mean[2], float covariance[2][2]) {
  int i, j, k, Q, fdr, a, b;
  float vx, vy, w_sum;
  w_sum = vx = vy = 0.0;
  for (i = 0; i < weighted_size; i++)
    for (j = 0; j < weighted_size; j++) {
      if (velocities[i][j][0] != 100.0 && velocities[i][j][1] != 100.0) {
        w_sum += weights[i][j];
        vx += weights[i][j] * velocities[i][j][0];
        vy += weights[i][j] * velocities[i][j][1];
      }
    }
  mean[0] = vx;
  mean[1] = vy;
  for (i = 0; i < 2; i++)
    for (j = 0; j < 2; j++)
      covariance[i][j] = 0.0;
  for (i = 0; i < weighted_size; i++)
    for (j = 0; j < weighted_size; j++) {
      if (velocities[i][j][0] != 100.0 && velocities[i][j][1] != 100.0) {
        covariance[0][0] += (velocities[i][j][0] - vx) *
                            (velocities[i][j][0] - vx) * weights[i][j];
        covariance[1][1] += (velocities[i][j][1] - vy) *
                            (velocities[i][j][1] - vy) * weights[i][j];
        covariance[0][1] += (velocities[i][j][0] - vx) *
                            (velocities[i][j][1] - vy) * weights[i][j];
      }
    }
  covariance[0][0] /= w_sum;
  covariance[0][1] /= w_sum;
  covariance[1][1] /= w_sum;
  covariance[1][0] = covariance[0][1];
}


x86 assembly (clang, -O0):
<calc_mean_and_covariance2>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x48(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x50(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12a1 <calc_mean_and_covariance2+0x1a1>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    128e <calc_mean_and_covariance2+0x18e>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa8,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,8),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xe84(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    1191 <calc_mean_and_covariance2+0x91>
jp     1191 <calc_mean_and_covariance2+0x91>
jmp    127b <calc_mean_and_covariance2+0x17b>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa8,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movss  0x4(%rax,%rcx,8),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xe47(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    11ce <calc_mean_and_covariance2+0xce>
jp     11ce <calc_mean_and_covariance2+0xce>
jmp    127b <calc_mean_and_covariance2+0x17b>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x54,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x54,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa8,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,8),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x54,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa8,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movss  0x4(%rax,%rcx,8),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
jmp    1280 <calc_mean_and_covariance2+0x180>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1149 <calc_mean_and_covariance2+0x49>
jmp    1293 <calc_mean_and_covariance2+0x193>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1136 <calc_mean_and_covariance2+0x36>
movss  -0x48(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x4c(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x4(%rax)
movl   $0x0,-0x2c(%rbp)
cmpl   $0x2,-0x2c(%rbp)
jge    131a <calc_mean_and_covariance2+0x21a>
movl   $0x0,-0x30(%rbp)
cmpl   $0x2,-0x30(%rbp)
jge    1307 <calc_mean_and_covariance2+0x207>
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    12d4 <calc_mean_and_covariance2+0x1d4>
jmp    130c <calc_mean_and_covariance2+0x20c>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    12c3 <calc_mean_and_covariance2+0x1c3>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1536 <calc_mean_and_covariance2+0x436>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1523 <calc_mean_and_covariance2+0x423>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa8,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,8),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xc99(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    137c <calc_mean_and_covariance2+0x27c>
jp     137c <calc_mean_and_covariance2+0x27c>
jmp    1510 <calc_mean_and_covariance2+0x410>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa8,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movss  0x4(%rax,%rcx,8),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xc5c(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    13b9 <calc_mean_and_covariance2+0x2b9>
jp     13b9 <calc_mean_and_covariance2+0x2b9>
jmp    1510 <calc_mean_and_covariance2+0x410>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa8,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,8),%xmm0
subss  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa8,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,8),%xmm1
subss  -0x48(%rbp),%xmm1
mulss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x54,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax)
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa8,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movss  0x4(%rax,%rcx,8),%xmm0
subss  -0x4c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa8,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movss  0x4(%rax,%rcx,8),%xmm1
subss  -0x4c(%rbp),%xmm1
mulss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x54,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x28(%rbp),%rax
movss  0xc(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0xc(%rax)
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa8,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,8),%xmm0
subss  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa8,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movss  0x4(%rax,%rcx,8),%xmm1
subss  -0x4c(%rbp),%xmm1
mulss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x54,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x28(%rbp),%rax
movss  0x4(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x4(%rax)
jmp    1515 <calc_mean_and_covariance2+0x415>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1334 <calc_mean_and_covariance2+0x234>
jmp    1528 <calc_mean_and_covariance2+0x428>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1321 <calc_mean_and_covariance2+0x221>
movss  -0x50(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax)
movss  -0x50(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movss  0x4(%rax),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,0x4(%rax)
movss  -0x50(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movss  0xc(%rax),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,0xc(%rax)
mov    -0x28(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0x8(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<calc_mean_and_covariance2>:
push   %rbx
test   %edx,%edx
jle    125a <calc_mean_and_covariance2+0x15a>
mov    %edx,%r9d
lea    0x4(%rsi),%rax
xorps  %xmm1,%xmm1
xorps  %xmm0,%xmm0
xor    %r10d,%r10d
movss  0xedf(%rip),%xmm2
mov    %rdi,%r11
jmp    1143 <calc_mean_and_covariance2+0x43>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r10
add    $0x54,%r11
add    $0xa8,%rax
cmp    %r9,%r10
je     118b <calc_mean_and_covariance2+0x8b>
xor    %ebx,%ebx
jmp    1159 <calc_mean_and_covariance2+0x59>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rbx
cmp    %rbx,%r9
je     1130 <calc_mean_and_covariance2+0x30>
movss  -0x4(%rax,%rbx,8),%xmm3
ucomiss %xmm2,%xmm3
jne    1166 <calc_mean_and_covariance2+0x66>
jnp    1150 <calc_mean_and_covariance2+0x50>
movss  (%rax,%rbx,8),%xmm4
ucomiss %xmm2,%xmm4
jne    1172 <calc_mean_and_covariance2+0x72>
jnp    1150 <calc_mean_and_covariance2+0x50>
movss  (%r11,%rbx,4),%xmm5
addss  %xmm5,%xmm0
shufps $0x0,%xmm5,%xmm5
unpcklps %xmm4,%xmm3
mulps  %xmm5,%xmm3
addps  %xmm3,%xmm1
jmp    1150 <calc_mean_and_covariance2+0x50>
movss  %xmm1,(%rcx)
movaps %xmm1,%xmm8
shufps $0x55,%xmm1,%xmm8
movss  %xmm8,0x4(%rcx)
xorps  %xmm3,%xmm3
movups %xmm3,(%r8)
test   %edx,%edx
jle    1264 <calc_mean_and_covariance2+0x164>
add    $0x4,%rsi
xorps  %xmm3,%xmm3
xor    %ecx,%ecx
xorps  %xmm4,%xmm4
xorps  %xmm6,%xmm6
jmp    11d8 <calc_mean_and_covariance2+0xd8>
xchg   %ax,%ax
add    $0x1,%rcx
add    $0x54,%rdi
add    $0xa8,%rsi
cmp    %r9,%rcx
je     126d <calc_mean_and_covariance2+0x16d>
xor    %eax,%eax
jmp    11e9 <calc_mean_and_covariance2+0xe9>
nopl   0x0(%rax)
add    $0x1,%rax
cmp    %rax,%r9
je     11c0 <calc_mean_and_covariance2+0xc0>
movss  -0x4(%rsi,%rax,8),%xmm7
ucomiss %xmm2,%xmm7
jne    11f6 <calc_mean_and_covariance2+0xf6>
jnp    11e0 <calc_mean_and_covariance2+0xe0>
movss  (%rsi,%rax,8),%xmm5
ucomiss %xmm2,%xmm5
jne    1202 <calc_mean_and_covariance2+0x102>
jnp    11e0 <calc_mean_and_covariance2+0xe0>
subss  %xmm1,%xmm7
mulss  %xmm7,%xmm7
mulss  (%rdi,%rax,4),%xmm7
addss  %xmm7,%xmm6
movss  %xmm6,(%r8)
movss  (%rsi,%rax,8),%xmm5
subss  %xmm8,%xmm5
mulss  %xmm5,%xmm5
mulss  (%rdi,%rax,4),%xmm5
addss  %xmm5,%xmm4
movss  %xmm4,0xc(%r8)
movsd  -0x4(%rsi,%rax,8),%xmm5
subps  %xmm1,%xmm5
movaps %xmm5,%xmm7
shufps $0x55,%xmm5,%xmm7
mulss  %xmm5,%xmm7
mulss  (%rdi,%rax,4),%xmm7
addss  %xmm7,%xmm3
movss  %xmm3,0x4(%r8)
jmp    11e0 <calc_mean_and_covariance2+0xe0>
movq   $0x0,(%rcx)
xorps  %xmm0,%xmm0
xorps  %xmm4,%xmm4
xorps  %xmm3,%xmm3
xorps  %xmm6,%xmm6
divss  %xmm0,%xmm6
movss  %xmm6,(%r8)
divss  %xmm0,%xmm3
movss  %xmm3,0x4(%r8)
divss  %xmm0,%xmm4
movss  %xmm4,0xc(%r8)
movss  %xmm3,0x8(%r8)
pop    %rbx
ret

LLVM IR (-O0):
define void @calc_mean_and_covariance2([21 x float]* %0, [21 x [2 x float]]* %1, i32 %2, float* %3, [2 x float]* %4) {
%6 = alloca [21 x float]*
%7 = alloca [21 x [2 x float]]*
%8 = alloca i32
%9 = alloca float*
%10 = alloca [2 x float]*
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca float
%19 = alloca float
%20 = alloca float
store [21 x float]* %0, [21 x float]** %6
store [21 x [2 x float]]* %1, [21 x [2 x float]]** %7
store i32 %2, i32* %8
store float* %3, float** %9
store [2 x float]* %4, [2 x float]** %10
store float 0.000000e+00, float* %19
store float 0.000000e+00, float* %18
store float 0.000000e+00, float* %20
store i32 0, i32* %11
br label %21
21: ; preds = %108, %5
%22 = load i32, i32* %11
%23 = load i32, i32* %8
%24 = icmp slt i32 %22, %23
br i1 %24, label %25, label %111
25: ; preds = %21
store i32 0, i32* %12
br label %26
26: ; preds = %104, %25
%27 = load i32, i32* %12
%28 = load i32, i32* %8
%29 = icmp slt i32 %27, %28
br i1 %29, label %30, label %107
30: ; preds = %26
%31 = load [21 x [2 x float]]*, [21 x [2 x float]]** %7
%32 = load i32, i32* %11
%33 = sext i32 %32 to i64
%34 = getelementptr inbounds [21 x [2 x float]], [21 x [2 x float]]* %31, i64 %33
%35 = load i32, i32* %12
%36 = sext i32 %35 to i64
%37 = getelementptr inbounds [21 x [2 x float]], [21 x [2 x float]]* %34, i64 0, i64 %36
%38 = getelementptr inbounds [2 x float], [2 x float]* %37, i64 0, i64 0
%39 = load float, float* %38
%40 = fpext float %39 to double
%41 = fcmp une double %40, 1.000000e+02
br i1 %41, label %42, label %103
42: ; preds = %30
%43 = load [21 x [2 x float]]*, [21 x [2 x float]]** %7
%44 = load i32, i32* %11
%45 = sext i32 %44 to i64
%46 = getelementptr inbounds [21 x [2 x float]], [21 x [2 x float]]* %43, i64 %45
%47 = load i32, i32* %12
%48 = sext i32 %47 to i64
%49 = getelementptr inbounds [21 x [2 x float]], [21 x [2 x float]]* %46, i64 0, i64 %48
%50 = getelementptr inbounds [2 x float], [2 x float]* %49, i64 0, i64 1
%51 = load float, float* %50
%52 = fpext float %51 to double
%53 = fcmp une double %52, 1.000000e+02
br i1 %53, label %54, label %103
54: ; preds = %42
%55 = load [21 x float]*, [21 x float]** %6
%56 = load i32, i32* %11
%57 = sext i32 %56 to i64
%58 = getelementptr inbounds [21 x float], [21 x float]* %55, i64 %57
%59 = load i32, i32* %12
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds [21 x float], [21 x float]* %58, i64 0, i64 %60
%62 = load float, float* %61
%63 = load float, float* %20
%64 = fadd float %63, %62
store float %64, float* %20
%65 = load [21 x float]*, [21 x float]** %6
%66 = load i32, i32* %11
%67 = sext i32 %66 to i64
%68 = getelementptr inbounds [21 x float], [21 x float]* %65, i64 %67
%69 = load i32, i32* %12
%70 = sext i32 %69 to i64
%71 = getelementptr inbounds [21 x float], [21 x float]* %68, i64 0, i64 %70
%72 = load float, float* %71
%73 = load [21 x [2 x float]]*, [21 x [2 x float]]** %7
%74 = load i32, i32* %11
%75 = sext i32 %74 to i64
%76 = getelementptr inbounds [21 x [2 x float]], [21 x [2 x float]]* %73, i64 %75
%77 = load i32, i32* %12
%78 = sext i32 %77 to i64
%79 = getelementptr inbounds [21 x [2 x float]], [21 x [2 x float]]* %76, i64 0, i64 %78
%80 = getelementptr inbounds [2 x float], [2 x float]* %79, i64 0, i64 0
%81 = load float, float* %80
%82 = load float, float* %18
%83 = call float @llvm.fmuladd.f32(float %72, float %81, float %82)
store float %83, float* %18
%84 = load [21 x float]*, [21 x float]** %6
%85 = load i32, i32* %11
%86 = sext i32 %85 to i64
%87 = getelementptr inbounds [21 x float], [21 x float]* %84, i64 %86
%88 = load i32, i32* %12
%89 = sext i32 %88 to i64
%90 = getelementptr inbounds [21 x float], [21 x float]* %87, i64 0, i64 %89
%91 = load float, float* %90
%92 = load [21 x [2 x float]]*, [21 x [2 x float]]** %7
%93 = load i32, i32* %11
%94 = sext i32 %93 to i64
%95 = getelementptr inbounds [21 x [2 x float]], [21 x [2 x float]]* %92, i64 %94
%96 = load i32, i32* %12
%97 = sext i32 %96 to i64
%98 = getelementptr inbounds [21 x [2 x float]], [21 x [2 x float]]* %95, i64 0, i64 %97
%99 = getelementptr inbounds [2 x float], [2 x float]* %98, i64 0, i64 1
%100 = load float, float* %99
%101 = load float, float* %19
%102 = call float @llvm.fmuladd.f32(float %91, float %100, float %101)
store float %102, float* %19
br label %103
103: ; preds = %54, %42, %30
br label %104
104: ; preds = %103
%105 = load i32, i32* %12
%106 = add nsw i32 %105, 1
store i32 %106, i32* %12
br label %26
107: ; preds = %26
br label %108
108: ; preds = %107
%109 = load i32, i32* %11
%110 = add nsw i32 %109, 1
store i32 %110, i32* %11
br label %21
111: ; preds = %21
%112 = load float, float* %18
%113 = load float*, float** %9
%114 = getelementptr inbounds float, float* %113, i64 0
store float %112, float* %114
%115 = load float, float* %19
%116 = load float*, float** %9
%117 = getelementptr inbounds float, float* %116, i64 1
store float %115, float* %117
store i32 0, i32* %11
br label %118
118: ; preds = %137, %111
%119 = load i32, i32* %11
%120 = icmp slt i32 %119, 2
br i1 %120, label %121, label %140
121: ; preds = %118
store i32 0, i32* %12
br label %122
122: ; preds = %133, %121
%123 = load i32, i32* %12
%124 = icmp slt i32 %123, 2
br i1 %124, label %125, label %136
125: ; preds = %122
%126 = load [2 x float]*, [2 x float]** %10
%127 = load i32, i32* %11
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds [2 x float], [2 x float]* %126, i64 %128
%130 = load i32, i32* %12
%131 = sext i32 %130 to i64
%132 = getelementptr inbounds [2 x float], [2 x float]* %129, i64 0, i64 %131
store float 0.000000e+00, float* %132
br label %133
133: ; preds = %125
%134 = load i32, i32* %12
%135 = add nsw i32 %134, 1
store i32 %135, i32* %12
br label %122
136: ; preds = %122
br label %137
137: ; preds = %136
%138 = load i32, i32* %11
%139 = add nsw i32 %138, 1
store i32 %139, i32* %11
br label %118
140: ; preds = %118
store i32 0, i32* %11
br label %141
141: ; preds = %288, %140
%142 = load i32, i32* %11
%143 = load i32, i32* %8
%144 = icmp slt i32 %142, %143
br i1 %144, label %145, label %291
145: ; preds = %141
store i32 0, i32* %12
br label %146
146: ; preds = %284, %145
%147 = load i32, i32* %12
%148 = load i32, i32* %8
%149 = icmp slt i32 %147, %148
br i1 %149, label %150, label %287
150: ; preds = %146
%151 = load [21 x [2 x float]]*, [21 x [2 x float]]** %7
%152 = load i32, i32* %11
%153 = sext i32 %152 to i64
%154 = getelementptr inbounds [21 x [2 x float]], [21 x [2 x float]]* %151, i64 %153
%155 = load i32, i32* %12
%156 = sext i32 %155 to i64
%157 = getelementptr inbounds [21 x [2 x float]], [21 x [2 x float]]* %154, i64 0, i64 %156
%158 = getelementptr inbounds [2 x float], [2 x float]* %157, i64 0, i64 0
%159 = load float, float* %158
%160 = fpext float %159 to double
%161 = fcmp une double %160, 1.000000e+02
br i1 %161, label %162, label %283
162: ; preds = %150
%163 = load [21 x [2 x float]]*, [21 x [2 x float]]** %7
%164 = load i32, i32* %11
%165 = sext i32 %164 to i64
%166 = getelementptr inbounds [21 x [2 x float]], [21 x [2 x float]]* %163, i64 %165
%167 = load i32, i32* %12
%168 = sext i32 %167 to i64
%169 = getelementptr inbounds [21 x [2 x float]], [21 x [2 x float]]* %166, i64 0, i64 %168
%170 = getelementptr inbounds [2 x float], [2 x float]* %169, i64 0, i64 1
%171 = load float, float* %170
%172 = fpext float %171 to double
%173 = fcmp une double %172, 1.000000e+02
br i1 %173, label %174, label %283
174: ; preds = %162
%175 = load [21 x [2 x float]]*, [21 x [2 x float]]** %7
%176 = load i32, i32* %11
%177 = sext i32 %176 to i64
%178 = getelementptr inbounds [21 x [2 x float]], [21 x [2 x float]]* %175, i64 %177
%179 = load i32, i32* %12
%180 = sext i32 %179 to i64
%181 = getelementptr inbounds [21 x [2 x float]], [21 x [2 x float]]* %178, i64 0, i64 %180
%182 = getelementptr inbounds [2 x float], [2 x float]* %181, i64 0, i64 0
%183 = load float, float* %182
%184 = load float, float* %18
%185 = fsub float %183, %184
%186 = load [21 x [2 x float]]*, [21 x [2 x float]]** %7
%187 = load i32, i32* %11
%188 = sext i32 %187 to i64
%189 = getelementptr inbounds [21 x [2 x float]], [21 x [2 x float]]* %186, i64 %188
%190 = load i32, i32* %12
%191 = sext i32 %190 to i64
%192 = getelementptr inbounds [21 x [2 x float]], [21 x [2 x float]]* %189, i64 0, i64 %191
%193 = getelementptr inbounds [2 x float], [2 x float]* %192, i64 0, i64 0
%194 = load float, float* %193
%195 = load float, float* %18
%196 = fsub float %194, %195
%197 = fmul float %185, %196
%198 = load [21 x float]*, [21 x float]** %6
%199 = load i32, i32* %11
%200 = sext i32 %199 to i64
%201 = getelementptr inbounds [21 x float], [21 x float]* %198, i64 %200
%202 = load i32, i32* %12
%203 = sext i32 %202 to i64
%204 = getelementptr inbounds [21 x float], [21 x float]* %201, i64 0, i64 %203
%205 = load float, float* %204
%206 = load [2 x float]*, [2 x float]** %10
%207 = getelementptr inbounds [2 x float], [2 x float]* %206, i64 0
%208 = getelementptr inbounds [2 x float], [2 x float]* %207, i64 0, i64 0
%209 = load float, float* %208
%210 = call float @llvm.fmuladd.f32(float %197, float %205, float %209)
store float %210, float* %208
%211 = load [21 x [2 x float]]*, [21 x [2 x float]]** %7
%212 = load i32, i32* %11
%213 = sext i32 %212 to i64
%214 = getelementptr inbounds [21 x [2 x float]], [21 x [2 x float]]* %211, i64 %213
%215 = load i32, i32* %12
%216 = sext i32 %215 to i64
%217 = getelementptr inbounds [21 x [2 x float]], [21 x [2 x float]]* %214, i64 0, i64 %216
%218 = getelementptr inbounds [2 x float], [2 x float]* %217, i64 0, i64 1
%219 = load float, float* %218
%220 = load float, float* %19
%221 = fsub float %219, %220
%222 = load [21 x [2 x float]]*, [21 x [2 x float]]** %7
%223 = load i32, i32* %11
%224 = sext i32 %223 to i64
%225 = getelementptr inbounds [21 x [2 x float]], [21 x [2 x float]]* %222, i64 %224
%226 = load i32, i32* %12
%227 = sext i32 %226 to i64
%228 = getelementptr inbounds [21 x [2 x float]], [21 x [2 x float]]* %225, i64 0, i64 %227
%229 = getelementptr inbounds [2 x float], [2 x float]* %228, i64 0, i64 1
%230 = load float, float* %229
%231 = load float, float* %19
%232 = fsub float %230, %231
%233 = fmul float %221, %232
%234 = load [21 x float]*, [21 x float]** %6
%235 = load i32, i32* %11
%236 = sext i32 %235 to i64
%237 = getelementptr inbounds [21 x float], [21 x float]* %234, i64 %236
%238 = load i32, i32* %12
%239 = sext i32 %238 to i64
%240 = getelementptr inbounds [21 x float], [21 x float]* %237, i64 0, i64 %239
%241 = load float, float* %240
%242 = load [2 x float]*, [2 x float]** %10
%243 = getelementptr inbounds [2 x float], [2 x float]* %242, i64 1
%244 = getelementptr inbounds [2 x float], [2 x float]* %243, i64 0, i64 1
%245 = load float, float* %244
%246 = call float @llvm.fmuladd.f32(float %233, float %241, float %245)
store float %246, float* %244
%247 = load [21 x [2 x float]]*, [21 x [2 x float]]** %7
%248 = load i32, i32* %11
%249 = sext i32 %248 to i64
%250 = getelementptr inbounds [21 x [2 x float]], [21 x [2 x float]]* %247, i64 %249
%251 = load i32, i32* %12
%252 = sext i32 %251 to i64
%253 = getelementptr inbounds [21 x [2 x float]], [21 x [2 x float]]* %250, i64 0, i64 %252
%254 = getelementptr inbounds [2 x float], [2 x float]* %253, i64 0, i64 0
%255 = load float, float* %254
%256 = load float, float* %18
%257 = fsub float %255, %256
%258 = load [21 x [2 x float]]*, [21 x [2 x float]]** %7
%259 = load i32, i32* %11
%260 = sext i32 %259 to i64
%261 = getelementptr inbounds [21 x [2 x float]], [21 x [2 x float]]* %258, i64 %260
%262 = load i32, i32* %12
%263 = sext i32 %262 to i64
%264 = getelementptr inbounds [21 x [2 x float]], [21 x [2 x float]]* %261, i64 0, i64 %263
%265 = getelementptr inbounds [2 x float], [2 x float]* %264, i64 0, i64 1
%266 = load float, float* %265
%267 = load float, float* %19
%268 = fsub float %266, %267
%269 = fmul float %257, %268
%270 = load [21 x float]*, [21 x float]** %6
%271 = load i32, i32* %11
%272 = sext i32 %271 to i64
%273 = getelementptr inbounds [21 x float], [21 x float]* %270, i64 %272
%274 = load i32, i32* %12
%275 = sext i32 %274 to i64
%276 = getelementptr inbounds [21 x float], [21 x float]* %273, i64 0, i64 %275
%277 = load float, float* %276
%278 = load [2 x float]*, [2 x float]** %10
%279 = getelementptr inbounds [2 x float], [2 x float]* %278, i64 0
%280 = getelementptr inbounds [2 x float], [2 x float]* %279, i64 0, i64 1
%281 = load float, float* %280
%282 = call float @llvm.fmuladd.f32(float %269, float %277, float %281)
store float %282, float* %280
br label %283
283: ; preds = %174, %162, %150
br label %284
284: ; preds = %283
%285 = load i32, i32* %12
%286 = add nsw i32 %285, 1
store i32 %286, i32* %12
br label %146
287: ; preds = %146
br label %288
288: ; preds = %287
%289 = load i32, i32* %11
%290 = add nsw i32 %289, 1
store i32 %290, i32* %11
br label %141
291: ; preds = %141
%292 = load float, float* %20
%293 = load [2 x float]*, [2 x float]** %10
%294 = getelementptr inbounds [2 x float], [2 x float]* %293, i64 0
%295 = getelementptr inbounds [2 x float], [2 x float]* %294, i64 0, i64 0
%296 = load float, float* %295
%297 = fdiv float %296, %292
store float %297, float* %295
%298 = load float, float* %20
%299 = load [2 x float]*, [2 x float]** %10
%300 = getelementptr inbounds [2 x float], [2 x float]* %299, i64 0
%301 = getelementptr inbounds [2 x float], [2 x float]* %300, i64 0, i64 1
%302 = load float, float* %301
%303 = fdiv float %302, %298
store float %303, float* %301
%304 = load float, float* %20
%305 = load [2 x float]*, [2 x float]** %10
%306 = getelementptr inbounds [2 x float], [2 x float]* %305, i64 1
%307 = getelementptr inbounds [2 x float], [2 x float]* %306, i64 0, i64 1
%308 = load float, float* %307
%309 = fdiv float %308, %304
store float %309, float* %307
%310 = load [2 x float]*, [2 x float]** %10
%311 = getelementptr inbounds [2 x float], [2 x float]* %310, i64 0
%312 = getelementptr inbounds [2 x float], [2 x float]* %311, i64 0, i64 1
%313 = load float, float* %312
%314 = load [2 x float]*, [2 x float]** %10
%315 = getelementptr inbounds [2 x float], [2 x float]* %314, i64 1
%316 = getelementptr inbounds [2 x float], [2 x float]* %315, i64 0, i64 0
store float %313, float* %316
ret void
}

LLVM IR (-O2):
define void @calc_mean_and_covariance2([21 x float]* nocapture %0, [21 x [2 x float]]* nocapture %1, i32 %2, float* nocapture writeonly %3, [2 x float]* nocapture %4) {
%6 = bitcast [2 x float]* %4 to i8*
%7 = icmp sgt i32 %2, 0
br i1 %7, label %10, label %8
8: ; preds = %5
store float 0.000000e+00, float* %3
%9 = getelementptr inbounds float, float* %3, i64 1
store float 0.000000e+00, float* %9
br label %98
10: ; preds = %5
%11 = zext i32 %2 to i64
br label %12
12: ; preds = %41, %10
%13 = phi i64 [ 0, %10 ], [ %42, %41 ]
%14 = phi float [ 0.000000e+00, %10 ], [ %37, %41 ]
%15 = phi <2 x float> [ zeroinitializer, %10 ], [ %38, %41 ]
br label %16
16: ; preds = %12, %36
%17 = phi i64 [ 0, %12 ], [ %39, %36 ]
%18 = phi float [ %14, %12 ], [ %37, %36 ]
%19 = phi <2 x float> [ %15, %12 ], [ %38, %36 ]
%20 = getelementptr inbounds [21 x [2 x float]], [21 x [2 x float]]* %1, i64 %13, i64 %17, i64 0
%21 = load float, float* %20
%22 = fcmp une float %21, 1.000000e+02
br i1 %22, label %23, label %36
23: ; preds = %16
%24 = getelementptr inbounds [21 x [2 x float]], [21 x [2 x float]]* %1, i64 %13, i64 %17, i64 1
%25 = load float, float* %24
%26 = fcmp une float %25, 1.000000e+02
br i1 %26, label %27, label %36
27: ; preds = %23
%28 = getelementptr inbounds [21 x float], [21 x float]* %0, i64 %13, i64 %17
%29 = load float, float* %28
%30 = fadd float %18, %29
%31 = insertelement <2 x float> poison, float %29, i64 0
%32 = shufflevector <2 x float> %31, <2 x float> poison, <2 x i32> zeroinitializer
%33 = insertelement <2 x float> poison, float %21, i64 0
%34 = insertelement <2 x float> %33, float %25, i64 1
%35 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %32, <2 x float> %34, <2 x float> %19)
br label %36
36: ; preds = %16, %23, %27
%37 = phi float [ %30, %27 ], [ %18, %23 ], [ %18, %16 ]
%38 = phi <2 x float> [ %35, %27 ], [ %19, %23 ], [ %19, %16 ]
%39 = add nuw nsw i64 %17, 1
%40 = icmp eq i64 %39, %11
br i1 %40, label %41, label %16
41: ; preds = %36
%42 = add nuw nsw i64 %13, 1
%43 = icmp eq i64 %42, %11
br i1 %43, label %44, label %12
44: ; preds = %41
%45 = extractelement <2 x float> %38, i64 0
store float %45, float* %3
%46 = getelementptr inbounds float, float* %3, i64 1
%47 = extractelement <2 x float> %38, i64 1
store float %47, float* %46
br i1 %7, label %48, label %98
48: ; preds = %44
%49 = getelementptr inbounds [2 x float], [2 x float]* %4, i64 0, i64 0
%50 = getelementptr inbounds [2 x float], [2 x float]* %4, i64 1, i64 1
%51 = getelementptr inbounds [2 x float], [2 x float]* %4, i64 0, i64 1
%52 = zext i32 %2 to i64
br label %53
53: ; preds = %95, %48
%54 = phi float [ 0.000000e+00, %48 ], [ %90, %95 ]
%55 = phi float [ 0.000000e+00, %48 ], [ %91, %95 ]
%56 = phi float [ 0.000000e+00, %48 ], [ %92, %95 ]
%57 = phi i64 [ 0, %48 ], [ %96, %95 ]
br label %58
58: ; preds = %53, %89
%59 = phi float [ %54, %53 ], [ %90, %89 ]
%60 = phi float [ %55, %53 ], [ %91, %89 ]
%61 = phi float [ %56, %53 ], [ %92, %89 ]
%62 = phi i64 [ 0, %53 ], [ %93, %89 ]
%63 = getelementptr inbounds [21 x [2 x float]], [21 x [2 x float]]* %1, i64 %57, i64 %62, i64 0
%64 = load float, float* %63
%65 = fcmp une float %64, 1.000000e+02
br i1 %65, label %66, label %89
66: ; preds = %58
%67 = getelementptr inbounds [21 x [2 x float]], [21 x [2 x float]]* %1, i64 %57, i64 %62, i64 1
%68 = load float, float* %67
%69 = fcmp une float %68, 1.000000e+02
br i1 %69, label %70, label %89
70: ; preds = %66
%71 = fsub float %64, %45
%72 = fmul float %71, %71
%73 = getelementptr inbounds [21 x float], [21 x float]* %0, i64 %57, i64 %62
%74 = load float, float* %73
%75 = tail call float @llvm.fmuladd.f32(float %72, float %74, float %61)
store float %75, float* %49
%76 = load float, float* %67
%77 = fsub float %76, %47
%78 = fmul float %77, %77
%79 = load float, float* %73
%80 = tail call float @llvm.fmuladd.f32(float %78, float %79, float %60)
store float %80, float* %50
%81 = bitcast float* %63 to <2 x float>*
%82 = load <2 x float>, <2 x float>* %81
%83 = fsub <2 x float> %82, %38
%84 = shufflevector <2 x float> %83, <2 x float> poison, <2 x i32> <i32 1, i32 undef>
%85 = fmul <2 x float> %83, %84
%86 = extractelement <2 x float> %85, i64 0
%87 = load float, float* %73
%88 = tail call float @llvm.fmuladd.f32(float %86, float %87, float %59)
store float %88, float* %51
br label %89
89: ; preds = %58, %66, %70
%90 = phi float [ %59, %58 ], [ %59, %66 ], [ %88, %70 ]
%91 = phi float [ %60, %58 ], [ %60, %66 ], [ %80, %70 ]
%92 = phi float [ %61, %58 ], [ %61, %66 ], [ %75, %70 ]
%93 = add nuw nsw i64 %62, 1
%94 = icmp eq i64 %93, %52
br i1 %94, label %95, label %58
95: ; preds = %89
%96 = add nuw nsw i64 %57, 1
%97 = icmp eq i64 %96, %52
br i1 %97, label %98, label %53
98: ; preds = %95, %8, %44
%99 = phi float [ %37, %44 ], [ 0.000000e+00, %8 ], [ %37, %95 ]
%100 = phi float [ 0.000000e+00, %44 ], [ 0.000000e+00, %8 ], [ %91, %95 ]
%101 = phi float [ 0.000000e+00, %44 ], [ 0.000000e+00, %8 ], [ %90, %95 ]
%102 = phi float [ 0.000000e+00, %44 ], [ 0.000000e+00, %8 ], [ %92, %95 ]
%103 = getelementptr inbounds [2 x float], [2 x float]* %4, i64 0, i64 0
%104 = fdiv float %102, %99
store float %104, float* %103
%105 = getelementptr inbounds [2 x float], [2 x float]* %4, i64 0, i64 1
%106 = fdiv float %101, %99
store float %106, float* %105
%107 = getelementptr inbounds [2 x float], [2 x float]* %4, i64 1, i64 1
%108 = fdiv float %100, %99
store float %108, float* %107
%109 = getelementptr inbounds [2 x float], [2 x float]* %4, i64 1, i64 0
store float %106, float* %109
ret void
}