void covcol(data, n, m, symmat) float **data, **symmat;
int n, m;
{
  float *mean, *vector();
  int i, j, j1, j2;
  mean = vector(m);
  for (j = 1; j <= m; j++) {
    mean[j] = 0.0;
    for (i = 1; i <= n; i++) {
      mean[j] += data[i][j];
    }
    mean[j] /= (float)n;
  }
  printf("\nMeans of column vectors:\n");
  for (j = 1; j <= m; j++) {
    printf("%7.1f", mean[j]);
  }
  printf("\n");
  for (i = 1; i <= n; i++) {
    for (j = 1; j <= m; j++) {
      data[i][j] -= mean[j];
    }
  }
  for (j1 = 1; j1 <= m; j1++) {
    for (j2 = j1; j2 <= m; j2++) {
      symmat[j1][j2] = 0.0;
      for (i = 1; i <= n; i++) {
        symmat[j1][j2] += data[i][j1] * data[i][j2];
      }
      symmat[j2][j1] = symmat[j1][j2];
    }
  }
  return;
}


x86 assembly (clang, -O0):
<covcol>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    -0x10(%rbp),%edi
mov    $0x0,%al
call   1040 <vector@plt>
mov    %rax,-0x20(%rbp)
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     11d8 <covcol+0xb8>
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     11af <covcol+0x8f>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    116e <covcol+0x4e>
cvtsi2ssl -0xc(%rbp),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    114b <covcol+0x2b>
lea    0xe21(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     1226 <covcol+0x106>
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xe0a(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11ed <covcol+0xcd>
lea    0xdec(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     12a6 <covcol+0x186>
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     1293 <covcol+0x173>
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    124e <covcol+0x12e>
jmp    1298 <covcol+0x178>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    123b <covcol+0x11b>
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     139b <covcol+0x27b>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     1388 <covcol+0x268>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1350 <covcol+0x230>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    12ea <covcol+0x1ca>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    12bf <covcol+0x19f>
jmp    138d <covcol+0x26d>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    12ad <covcol+0x18d>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<covcol>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %rcx,%r14
mov    %edx,%r12d
mov    %esi,%r15d
mov    %rdi,%rbx
mov    %edx,%edi
xor    %eax,%eax
call   1060 <vector@plt>
mov    %rax,%r13
test   %r12d,%r12d
jle    12c5 <covcol+0x185>
cvtsi2ss %r15d,%xmm0
lea    0x1(%r15),%r8d
lea    0x1(%r12),%r9d
lea    -0x1(%r8),%rcx
add    $0xfffffffffffffffe,%r8
mov    %ecx,%edx
and    $0x3,%edx
and    $0xfffffffffffffffc,%rcx
mov    $0x1,%esi
jmp    11bb <covcol+0x7b>
cs nopw 0x0(%rax,%rax,1)
nop
xorps  %xmm1,%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0x0(%r13,%rsi,4)
add    $0x1,%rsi
cmp    %r9,%rsi
je     127e <covcol+0x13e>
movl   $0x0,0x0(%r13,%rsi,4)
test   %r15d,%r15d
jle    11a0 <covcol+0x60>
cmp    $0x3,%r8
jae    11e0 <covcol+0xa0>
mov    $0x1,%edi
xorps  %xmm1,%xmm1
test   %rdx,%rdx
jne    124e <covcol+0x10e>
jmp    11a3 <covcol+0x63>
xchg   %ax,%ax
xorps  %xmm1,%xmm1
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x8(%rbx,%rdi,8),%rbp
addss  0x0(%rbp,%rsi,4),%xmm1
movss  %xmm1,0x0(%r13,%rsi,4)
mov    0x10(%rbx,%rdi,8),%rbp
addss  0x0(%rbp,%rsi,4),%xmm1
movss  %xmm1,0x0(%r13,%rsi,4)
mov    0x18(%rbx,%rdi,8),%rbp
addss  0x0(%rbp,%rsi,4),%xmm1
movss  %xmm1,0x0(%r13,%rsi,4)
mov    0x20(%rbx,%rdi,8),%rbp
addss  0x0(%rbp,%rsi,4),%xmm1
movss  %xmm1,0x0(%r13,%rsi,4)
add    $0x4,%rdi
cmp    %rdi,%rcx
jne    11f0 <covcol+0xb0>
add    $0x1,%rdi
test   %rdx,%rdx
je     11a3 <covcol+0x63>
lea    (%rbx,%rdi,8),%rdi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%rdi,%rbp,8),%rax
addss  (%rax,%rsi,4),%xmm1
movss  %xmm1,0x0(%r13,%rsi,4)
add    $0x1,%rbp
cmp    %rbp,%rdx
jne    1260 <covcol+0x120>
jmp    11a3 <covcol+0x63>
lea    0xd81(%rip),%rdi
mov    %r9,(%rsp)
call   1040 <puts@plt>
test   %r12d,%r12d
jle    12d1 <covcol+0x191>
mov    $0x1,%ebp
nopl   0x0(%rax,%rax,1)
movss  0x0(%r13,%rbp,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xd4e(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
add    $0x1,%rbp
cmp    %rbp,(%rsp)
jne    12a0 <covcol+0x160>
jmp    12d1 <covcol+0x191>
lea    0xd3a(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
test   %r15d,%r15d
jle    1500 <covcol+0x3c0>
lea    0x1(%r12),%eax
lea    0x1(%r15),%ecx
lea    0x0(,%rax,4),%r9
add    %r13,%r9
mov    %r13,%rdx
add    $0x4,%rdx
mov    %rdx,(%rsp)
lea    -0x1(%rax),%rdi
lea    -0x9(%rax),%rbp
mov    %rbp,0x20(%rsp)
shr    $0x3,%rbp
add    $0x1,%rbp
mov    %rdi,%rdx
and    $0xfffffffffffffff8,%rdx
mov    %rdx,0x18(%rsp)
add    $0x1,%rdx
mov    %rdx,0x10(%rsp)
mov    %rbp,%rdx
and    $0xfffffffffffffffe,%rdx
mov    %rdx,0x8(%rsp)
mov    $0x1,%r11d
jmp    135d <covcol+0x21d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%r11
cmp    %rcx,%r11
je     1500 <covcol+0x3c0>
test   %r12d,%r12d
jle    1350 <covcol+0x210>
mov    (%rbx,%r11,8),%r10
mov    $0x1,%r8d
cmp    $0x8,%rdi
jb     1450 <covcol+0x310>
lea    0x4(%r10),%rdx
cmp    %r9,%rdx
jae    138d <covcol+0x24d>
lea    (%r10,%rax,4),%rdx
cmp    %rdx,(%rsp)
jb     1450 <covcol+0x310>
cmpq   $0x8,0x20(%rsp)
jae    1399 <covcol+0x259>
xor    %esi,%esi
jmp    13fe <covcol+0x2be>
mov    0x8(%rsp),%rdx
xor    %esi,%esi
movups 0x4(%r13,%rsi,4),%xmm0
movups 0x14(%r13,%rsi,4),%xmm1
movups 0x4(%r10,%rsi,4),%xmm2
subps  %xmm0,%xmm2
movups 0x14(%r10,%rsi,4),%xmm0
subps  %xmm1,%xmm0
movups 0x24(%r10,%rsi,4),%xmm1
movups 0x34(%r10,%rsi,4),%xmm3
movups %xmm2,0x4(%r10,%rsi,4)
movups %xmm0,0x14(%r10,%rsi,4)
movups 0x24(%r13,%rsi,4),%xmm0
subps  %xmm0,%xmm1
movups 0x34(%r13,%rsi,4),%xmm0
subps  %xmm0,%xmm3
movups %xmm1,0x24(%r10,%rsi,4)
movups %xmm3,0x34(%r10,%rsi,4)
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rdx
jne    13a0 <covcol+0x260>
test   $0x1,%bpl
je     1434 <covcol+0x2f4>
shl    $0x2,%rsi
or     $0x4,%rsi
movups 0x0(%r13,%rsi,1),%xmm0
movups 0x10(%r13,%rsi,1),%xmm1
movups (%r10,%rsi,1),%xmm2
subps  %xmm0,%xmm2
movups 0x10(%r10,%rsi,1),%xmm0
subps  %xmm1,%xmm0
movups %xmm2,(%r10,%rsi,1)
movups %xmm0,0x10(%r10,%rsi,1)
mov    0x10(%rsp),%r8
cmp    0x18(%rsp),%rdi
je     1350 <covcol+0x210>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %eax,%esi
sub    %r8d,%esi
mov    %r8,%rdx
not    %rdx
add    %rax,%rdx
and    $0x3,%rsi
je     148d <covcol+0x34d>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%r10,%r8,4),%xmm0
subss  0x0(%r13,%r8,4),%xmm0
movss  %xmm0,(%r10,%r8,4)
add    $0x1,%r8
add    $0xffffffffffffffff,%rsi
jne    1470 <covcol+0x330>
cmp    $0x3,%rdx
jb     1350 <covcol+0x210>
nopw   0x0(%rax,%rax,1)
movss  (%r10,%r8,4),%xmm0
subss  0x0(%r13,%r8,4),%xmm0
movss  0x4(%r10,%r8,4),%xmm1
movss  %xmm0,(%r10,%r8,4)
subss  0x4(%r13,%r8,4),%xmm1
movss  %xmm1,0x4(%r10,%r8,4)
movss  0x8(%r10,%r8,4),%xmm0
subss  0x8(%r13,%r8,4),%xmm0
movss  %xmm0,0x8(%r10,%r8,4)
movss  0xc(%r10,%r8,4),%xmm0
subss  0xc(%r13,%r8,4),%xmm0
movss  %xmm0,0xc(%r10,%r8,4)
add    $0x4,%r8
cmp    %r8,%rax
jne    14a0 <covcol+0x360>
jmp    1350 <covcol+0x210>
test   %r12d,%r12d
jle    15e3 <covcol+0x4a3>
lea    0x1(%r15),%r8d
add    $0x1,%r12d
lea    -0x1(%r8),%r9
mov    %r9,%rdx
and    $0xfffffffffffffffe,%rdx
neg    %rdx
mov    $0x1,%ebp
jmp    153d <covcol+0x3fd>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rbp
cmp    %r12,%rbp
je     15e3 <covcol+0x4a3>
mov    (%r14,%rbp,8),%rdi
mov    %rbp,%rsi
jmp    1565 <covcol+0x425>
cs nopw 0x0(%rax,%rax,1)
xorps  %xmm0,%xmm0
mov    (%r14,%rsi,8),%rax
movss  %xmm0,(%rax,%rbp,4)
add    $0x1,%rsi
cmp    %r12,%rsi
je     1530 <covcol+0x3f0>
movl   $0x0,(%rdi,%rsi,4)
test   %r15d,%r15d
jle    1550 <covcol+0x410>
mov    $0x1,%eax
xorps  %xmm0,%xmm0
cmp    $0x2,%r8d
je     15c1 <covcol+0x481>
nop
mov    (%rbx,%rax,8),%rcx
movss  (%rcx,%rbp,4),%xmm1
mulss  (%rcx,%rsi,4),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%rdi,%rsi,4)
mov    0x8(%rbx,%rax,8),%rcx
movss  (%rcx,%rbp,4),%xmm0
mulss  (%rcx,%rsi,4),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rdi,%rsi,4)
lea    (%rdx,%rax,1),%rcx
add    $0x2,%rcx
add    $0x2,%rax
cmp    $0x1,%rcx
jne    1580 <covcol+0x440>
test   $0x1,%r9b
je     1553 <covcol+0x413>
mov    (%rbx,%rax,8),%rax
movss  (%rax,%rbp,4),%xmm1
mulss  (%rax,%rsi,4),%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,(%rdi,%rsi,4)
jmp    1553 <covcol+0x413>
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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