void corcol(data, n, m, symmat) float **data, **symmat;
int n, m;
{
  float eps = 0.005;
  float x, *mean, *stddev, *vector();
  int i, j, j1, j2;
  mean = vector(m);
  stddev = 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 (j = 1; j <= m; j++) {
    stddev[j] = 0.0;
    for (i = 1; i <= n; i++) {
      stddev[j] += ((data[i][j] - mean[j]) * (data[i][j] - mean[j]));
    }
    stddev[j] /= (float)n;
    stddev[j] = sqrt(stddev[j]);
    if (stddev[j] <= eps)
      stddev[j] = 1.0;
  }
  printf("\nStandard deviations of columns:\n");
  for (j = 1; j <= m; j++) {
    printf("%7.1f", stddev[j]);
  }
  printf("\n");
  for (i = 1; i <= n; i++) {
    for (j = 1; j <= m; j++) {
      data[i][j] -= mean[j];
      x = sqrt((float)n);
      x *= stddev[j];
      data[i][j] /= x;
    }
  }
  for (j1 = 1; j1 <= m - 1; j1++) {
    symmat[j1][j1] = 1.0;
    for (j2 = j1 + 1; 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];
    }
  }
  symmat[m][m] = 1.0;
  return;
}


x86 assembly (clang, -O0):
<corcol>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
movss  0xeb2(%rip),%xmm0
movss  %xmm0,-0x1c(%rbp)
mov    -0x10(%rbp),%edi
mov    $0x0,%al
call   1040 <vector@plt>
mov    %rax,-0x28(%rbp)
mov    -0x10(%rbp),%edi
mov    $0x0,%al
call   1040 <vector@plt>
mov    %rax,-0x30(%rbp)
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     1203 <corcol+0xd3>
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     11da <corcol+0xaa>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1199 <corcol+0x69>
cvtsi2ssl -0xc(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1176 <corcol+0x46>
lea    0xdfe(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     1251 <corcol+0x121>
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xde7(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1218 <corcol+0xe8>
lea    0xdf1(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     1386 <corcol+0x256>
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1301 <corcol+0x1d1>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm2
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1289 <corcol+0x159>
cvtsi2ssl -0xc(%rbp),%xmm1
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
call   1050 <sqrt@plt>
cvtsd2ss %xmm0,%xmm0
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x1c(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jb     1373 <corcol+0x243>
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  0xc96(%rip),%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    1378 <corcol+0x248>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1266 <corcol+0x136>
lea    0xc9c(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     13d4 <corcol+0x2a4>
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xc64(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    139b <corcol+0x26b>
lea    0xc6e(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     14a5 <corcol+0x375>
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     1492 <corcol+0x362>
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
cvtsi2ssl -0xc(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
call   1050 <sqrt@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mulss  -0x20(%rbp),%xmm0
movss  %xmm0,-0x20(%rbp)
movss  -0x20(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    13fc <corcol+0x2cc>
jmp    1497 <corcol+0x367>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    13e9 <corcol+0x2b9>
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     15bf <corcol+0x48f>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movss  0xb2f(%rip),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     15ac <corcol+0x47c>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1574 <corcol+0x444>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    150e <corcol+0x3de>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    14e3 <corcol+0x3b3>
jmp    15b1 <corcol+0x481>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    14ac <corcol+0x37c>
mov    -0x18(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x10(%rbp),%rcx
movss  0xa2d(%rip),%xmm0
movss  %xmm0,(%rax,%rcx,4)
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<corcol>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %rcx,%r12
mov    %edx,%ebp
mov    %esi,%r14d
mov    %rdi,%rbx
mov    %edx,%edi
xor    %eax,%eax
call   1060 <vector@plt>
mov    %rax,%r13
mov    %ebp,%edi
xor    %eax,%eax
call   1060 <vector@plt>
mov    %rax,%r15
test   %ebp,%ebp
mov    %r12,0x30(%rsp)
mov    %rbp,0x8(%rsp)
mov    %r14,0x18(%rsp)
jle    144c <corcol+0x2fc>
cvtsi2ss %r14d,%xmm1
lea    0x1(%r14),%r8d
lea    0x1(%rbp),%r12d
lea    -0x1(%r8),%rcx
add    $0xfffffffffffffffe,%r8
mov    %ecx,%eax
and    $0x3,%eax
mov    %rcx,0x28(%rsp)
and    $0xfffffffffffffffc,%rcx
mov    $0x1,%edx
jmp    11eb <corcol+0x9b>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xorps  %xmm0,%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,0x0(%r13,%rdx,4)
add    $0x1,%rdx
cmp    %r12,%rdx
je     129f <corcol+0x14f>
movl   $0x0,0x0(%r13,%rdx,4)
test   %r14d,%r14d
jle    11d0 <corcol+0x80>
cmp    $0x3,%r8
jae    1210 <corcol+0xc0>
mov    $0x1,%esi
xorps  %xmm0,%xmm0
test   %rax,%rax
jne    127a <corcol+0x12a>
jmp    11d3 <corcol+0x83>
xchg   %ax,%ax
xorps  %xmm0,%xmm0
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x8(%rbx,%rsi,8),%rdi
addss  (%rdi,%rdx,4),%xmm0
movss  %xmm0,0x0(%r13,%rdx,4)
mov    0x10(%rbx,%rsi,8),%rdi
addss  (%rdi,%rdx,4),%xmm0
movss  %xmm0,0x0(%r13,%rdx,4)
mov    0x18(%rbx,%rsi,8),%rdi
addss  (%rdi,%rdx,4),%xmm0
movss  %xmm0,0x0(%r13,%rdx,4)
mov    0x20(%rbx,%rsi,8),%rdi
addss  (%rdi,%rdx,4),%xmm0
movss  %xmm0,0x0(%r13,%rdx,4)
add    $0x4,%rsi
cmp    %rsi,%rcx
jne    1220 <corcol+0xd0>
add    $0x1,%rsi
test   %rax,%rax
je     11d3 <corcol+0x83>
lea    (%rbx,%rsi,8),%rsi
xor    %edi,%edi
mov    (%rsi,%rdi,8),%rbp
addss  0x0(%rbp,%rdx,4),%xmm0
movss  %xmm0,0x0(%r13,%rdx,4)
add    $0x1,%rdi
cmp    %rdi,%rax
jne    1280 <corcol+0x130>
jmp    11d3 <corcol+0x83>
mov    %r8,0x20(%rsp)
movss  %xmm1,0x4(%rsp)
mov    %r12,0x10(%rsp)
lea    0xd58(%rip),%rdi
call   1040 <puts@plt>
cmpl   $0x0,0x8(%rsp)
jle    1458 <corcol+0x308>
mov    $0x1,%ebp
lea    0xd36(%rip),%r14
mov    0x10(%rsp),%r12
nopw   0x0(%rax,%rax,1)
movss  0x0(%r13,%rbp,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
add    $0x1,%rbp
cmp    %rbp,%r12
jne    12e0 <corcol+0x190>
mov    $0xa,%edi
call   1030 <putchar@plt>
cmpl   $0x0,0x8(%rsp)
jle    1462 <corcol+0x312>
mov    0x28(%rsp),%rbp
mov    %rbp,%r12
and    $0xfffffffffffffffe,%r12
neg    %r12
mov    $0x1,%r14d
xorps  %xmm3,%xmm3
movss  0xccd(%rip),%xmm4
movss  0xcc9(%rip),%xmm5
mov    0x10(%rsp),%rdx
movss  0x4(%rsp),%xmm2
mov    0x20(%rsp),%rsi
jmp    139c <corcol+0x24c>
nopl   (%rax)
call   1070 <sqrtf@plt>
movss  0xca7(%rip),%xmm5
movss  0xc9b(%rip),%xmm4
xorps  %xmm3,%xmm3
mov    0x20(%rsp),%rsi
movss  0x4(%rsp),%xmm2
mov    0x10(%rsp),%rdx
movaps %xmm0,%xmm1
cmpnless %xmm4,%xmm1
andps  %xmm1,%xmm0
andnps %xmm5,%xmm1
orps   %xmm0,%xmm1
movss  %xmm1,(%r15,%r14,4)
add    $0x1,%r14
cmp    %rdx,%r14
je     1677 <corcol+0x527>
movl   $0x0,(%r15,%r14,4)
xorps  %xmm0,%xmm0
cmpl   $0x0,0x18(%rsp)
jle    1436 <corcol+0x2e6>
mov    $0x1,%eax
xorps  %xmm0,%xmm0
test   %rsi,%rsi
je     1411 <corcol+0x2c1>
nop
mov    (%rbx,%rax,8),%rcx
movss  (%rcx,%r14,4),%xmm1
subss  0x0(%r13,%r14,4),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%r15,%r14,4)
mov    0x8(%rbx,%rax,8),%rcx
movss  (%rcx,%r14,4),%xmm0
subss  0x0(%r13,%r14,4),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%r15,%r14,4)
lea    (%r12,%rax,1),%rcx
add    $0x2,%rcx
add    $0x2,%rax
cmp    $0x1,%rcx
jne    13c0 <corcol+0x270>
test   $0x1,%bpl
je     1436 <corcol+0x2e6>
mov    (%rbx,%rax,8),%rax
movss  (%rax,%r14,4),%xmm1
subss  0x0(%r13,%r14,4),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,(%r15,%r14,4)
divss  %xmm2,%xmm0
ucomiss %xmm3,%xmm0
jb     1350 <corcol+0x200>
sqrtss %xmm0,%xmm0
jmp    1378 <corcol+0x228>
lea    0xbbb(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0xbbf(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
cmpl   $0x0,0x18(%rsp)
jle    1537 <corcol+0x3e7>
mov    0x18(%rsp),%rcx
xorps  %xmm2,%xmm2
cvtsi2ss %ecx,%xmm2
mov    0x8(%rsp),%rax
lea    0x1(%rax),%ebp
lea    0x1(%rcx),%eax
mov    %rax,0x20(%rsp)
mov    $0x1,%r14d
xorps  %xmm3,%xmm3
sqrtss %xmm2,%xmm3
xorps  %xmm4,%xmm4
movss  %xmm2,0x10(%rsp)
movss  %xmm3,0x4(%rsp)
jmp    14cb <corcol+0x37b>
nopl   (%rax)
add    $0x1,%r14
cmp    0x20(%rsp),%r14
je     1537 <corcol+0x3e7>
cmpl   $0x0,0x8(%rsp)
jle    14c0 <corcol+0x370>
mov    (%rbx,%r14,8),%rax
mov    $0x1,%r12d
jmp    1503 <corcol+0x3b3>
xchg   %ax,%ax
mulss  (%r15,%r12,4),%xmm0
mov    (%rbx,%r14,8),%rax
movss  (%rax,%r12,4),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,(%rax,%r12,4)
add    $0x1,%r12
cmp    %r12,%rbp
je     14c0 <corcol+0x370>
movss  (%rax,%r12,4),%xmm0
subss  0x0(%r13,%r12,4),%xmm0
movss  %xmm0,(%rax,%r12,4)
ucomiss %xmm4,%xmm2
movaps %xmm3,%xmm0
jae    14e0 <corcol+0x390>
movaps %xmm2,%xmm0
call   1070 <sqrtf@plt>
xorps  %xmm4,%xmm4
movss  0x4(%rsp),%xmm3
movss  0x10(%rsp),%xmm2
jmp    14e0 <corcol+0x390>
mov    0x8(%rsp),%r13
cmp    $0x2,%r13d
mov    0x30(%rsp),%r12
jl     165a <corcol+0x50a>
mov    0x18(%rsp),%rax
lea    0x1(%rax),%r11d
lea    0x1(%r13),%r15d
mov    %r13d,%r8d
lea    -0x1(%r11),%r14
mov    %r14,%rdi
and    $0xfffffffffffffffe,%rdi
neg    %rdi
mov    $0x2,%r10d
mov    $0x1,%r9d
jmp    158d <corcol+0x43d>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r10
cmp    %r8,%r9
je     165a <corcol+0x50a>
mov    %r9,%rdx
mov    (%r12,%r9,8),%rbp
movl   $0x3f800000,0x0(%rbp,%r9,4)
80 3f
add    $0x1,%r9
mov    %r10,%rax
jmp    15c5 <corcol+0x475>
cs nopw 0x0(%rax,%rax,1)
xorps  %xmm0,%xmm0
mov    (%r12,%rax,8),%rcx
movss  %xmm0,(%rcx,%rdx,4)
add    $0x1,%rax
cmp    %r15,%rax
je     1580 <corcol+0x430>
movl   $0x0,0x0(%rbp,%rax,4)
cmpl   $0x0,0x18(%rsp)
jle    15b0 <corcol+0x460>
mov    $0x1,%esi
xorps  %xmm0,%xmm0
cmp    $0x2,%r11d
je     1633 <corcol+0x4e3>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%rbx,%rsi,8),%rcx
movss  (%rcx,%rdx,4),%xmm1
mulss  (%rcx,%rax,4),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,0x0(%rbp,%rax,4)
mov    0x8(%rbx,%rsi,8),%rcx
movss  (%rcx,%rdx,4),%xmm0
mulss  (%rcx,%rax,4),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x0(%rbp,%rax,4)
lea    (%rdi,%rsi,1),%rcx
add    $0x2,%rcx
add    $0x2,%rsi
cmp    $0x1,%rcx
jne    15f0 <corcol+0x4a0>
test   $0x1,%r14b
je     15b3 <corcol+0x463>
mov    (%rbx,%rsi,8),%rcx
movss  (%rcx,%rdx,4),%xmm1
mulss  (%rcx,%rax,4),%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,0x0(%rbp,%rax,4)
jmp    15b3 <corcol+0x463>
movslq %r13d,%rax
mov    (%r12,%rax,8),%rcx
movl   $0x3f800000,(%rcx,%rax,4)
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0x9aa(%rip),%rdi
mov    %rdx,%r12
call   1040 <puts@plt>
cmpl   $0x0,0x8(%rsp)
jle    146e <corcol+0x31e>
mov    $0x1,%ebp
lea    0x96b(%rip),%r14
nopl   (%rax)
movss  (%r15,%rbp,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
add    $0x1,%rbp
cmp    %rbp,%r12
jne    16a0 <corcol+0x550>
jmp    146e <corcol+0x31e>

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

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