void iterate(float (*R)[4][4], int n) {
  int it;
  for (it = 0; it < n; it++) {
    R[0][0][0] += R[0][0][1];
    R[0][0][1] += R[0][0][2];
    R[0][0][2] += R[0][0][3];
    R[0][1][0] += R[0][1][1];
    R[0][1][1] += R[0][1][2];
    R[0][1][2] += R[0][1][3];
    R[0][2][0] += R[0][2][1];
    R[0][2][1] += R[0][2][2];
    R[0][2][2] += R[0][2][3];
    R[0][3][0] += R[0][3][1];
    R[0][3][1] += R[0][3][2];
    R[0][3][2] += R[0][3][3];
    R[1][0][0] += R[1][0][1];
    R[1][0][1] += R[1][0][2];
    R[1][0][2] += R[1][0][3];
    R[1][1][0] += R[1][1][1];
    R[1][1][1] += R[1][1][2];
    R[1][1][2] += R[1][1][3];
    R[1][2][0] += R[1][2][1];
    R[1][2][1] += R[1][2][2];
    R[1][2][2] += R[1][2][3];
    R[1][3][0] += R[1][3][1];
    R[1][3][1] += R[1][3][2];
    R[1][3][2] += R[1][3][3];
    R[2][0][0] += R[2][0][1];
    R[2][0][1] += R[2][0][2];
    R[2][0][2] += R[2][0][3];
    R[2][1][0] += R[2][1][1];
    R[2][1][1] += R[2][1][2];
    R[2][1][2] += R[2][1][3];
    R[2][2][0] += R[2][2][1];
    R[2][2][1] += R[2][2][2];
    R[2][2][2] += R[2][2][3];
    R[2][3][0] += R[2][3][1];
    R[2][3][1] += R[2][3][2];
    R[2][3][2] += R[2][3][3];
    R[3][0][0] += R[3][0][1];
    R[3][0][1] += R[3][0][2];
    R[3][0][2] += R[3][0][3];
    R[3][1][0] += R[3][1][1];
    R[3][1][1] += R[3][1][2];
    R[3][1][2] += R[3][1][3];
    R[3][2][0] += R[3][2][1];
    R[3][2][1] += R[3][2][2];
    R[3][2][2] += R[3][2][3];
    R[3][3][0] += R[3][3][1];
    R[3][3][1] += R[3][3][2];
    R[3][3][2] += R[3][3][3];
  }
}


x86 assembly (clang, -O0):
<iterate>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1652 <iterate+0x552>
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  (%rax),%xmm0
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0x4(%rax),%xmm0
movss  %xmm0,0x4(%rax)
mov    -0x8(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0x8(%rax),%xmm0
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0x10(%rax),%xmm0
movss  %xmm0,0x10(%rax)
mov    -0x8(%rbp),%rax
movss  0x18(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0x14(%rax),%xmm0
movss  %xmm0,0x14(%rax)
mov    -0x8(%rbp),%rax
movss  0x1c(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0x18(%rax),%xmm0
movss  %xmm0,0x18(%rax)
mov    -0x8(%rbp),%rax
movss  0x24(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0x20(%rax),%xmm0
movss  %xmm0,0x20(%rax)
mov    -0x8(%rbp),%rax
movss  0x28(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0x24(%rax),%xmm0
movss  %xmm0,0x24(%rax)
mov    -0x8(%rbp),%rax
movss  0x2c(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0x28(%rax),%xmm0
movss  %xmm0,0x28(%rax)
mov    -0x8(%rbp),%rax
movss  0x34(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0x30(%rax),%xmm0
movss  %xmm0,0x30(%rax)
mov    -0x8(%rbp),%rax
movss  0x38(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0x34(%rax),%xmm0
movss  %xmm0,0x34(%rax)
mov    -0x8(%rbp),%rax
movss  0x3c(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0x38(%rax),%xmm0
movss  %xmm0,0x38(%rax)
mov    -0x8(%rbp),%rax
movss  0x44(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0x40(%rax),%xmm0
movss  %xmm0,0x40(%rax)
mov    -0x8(%rbp),%rax
movss  0x48(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0x44(%rax),%xmm0
movss  %xmm0,0x44(%rax)
mov    -0x8(%rbp),%rax
movss  0x4c(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0x48(%rax),%xmm0
movss  %xmm0,0x48(%rax)
mov    -0x8(%rbp),%rax
movss  0x54(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0x50(%rax),%xmm0
movss  %xmm0,0x50(%rax)
mov    -0x8(%rbp),%rax
movss  0x58(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0x54(%rax),%xmm0
movss  %xmm0,0x54(%rax)
mov    -0x8(%rbp),%rax
movss  0x5c(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0x58(%rax),%xmm0
movss  %xmm0,0x58(%rax)
mov    -0x8(%rbp),%rax
movss  0x64(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0x60(%rax),%xmm0
movss  %xmm0,0x60(%rax)
mov    -0x8(%rbp),%rax
movss  0x68(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0x64(%rax),%xmm0
movss  %xmm0,0x64(%rax)
mov    -0x8(%rbp),%rax
movss  0x6c(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0x68(%rax),%xmm0
movss  %xmm0,0x68(%rax)
mov    -0x8(%rbp),%rax
movss  0x74(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0x70(%rax),%xmm0
movss  %xmm0,0x70(%rax)
mov    -0x8(%rbp),%rax
movss  0x78(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0x74(%rax),%xmm0
movss  %xmm0,0x74(%rax)
mov    -0x8(%rbp),%rax
movss  0x7c(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0x78(%rax),%xmm0
movss  %xmm0,0x78(%rax)
mov    -0x8(%rbp),%rax
movss  0x84(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0x80(%rax),%xmm0
movss  %xmm0,0x80(%rax)
mov    -0x8(%rbp),%rax
movss  0x88(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0x84(%rax),%xmm0
movss  %xmm0,0x84(%rax)
mov    -0x8(%rbp),%rax
movss  0x8c(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0x88(%rax),%xmm0
movss  %xmm0,0x88(%rax)
mov    -0x8(%rbp),%rax
movss  0x94(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0x90(%rax),%xmm0
movss  %xmm0,0x90(%rax)
mov    -0x8(%rbp),%rax
movss  0x98(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0x94(%rax),%xmm0
movss  %xmm0,0x94(%rax)
mov    -0x8(%rbp),%rax
movss  0x9c(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0x98(%rax),%xmm0
movss  %xmm0,0x98(%rax)
mov    -0x8(%rbp),%rax
movss  0xa4(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0xa0(%rax),%xmm0
movss  %xmm0,0xa0(%rax)
mov    -0x8(%rbp),%rax
movss  0xa8(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0xa4(%rax),%xmm0
movss  %xmm0,0xa4(%rax)
mov    -0x8(%rbp),%rax
movss  0xac(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0xa8(%rax),%xmm0
movss  %xmm0,0xa8(%rax)
mov    -0x8(%rbp),%rax
movss  0xb4(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0xb0(%rax),%xmm0
movss  %xmm0,0xb0(%rax)
mov    -0x8(%rbp),%rax
movss  0xb8(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0xb4(%rax),%xmm0
movss  %xmm0,0xb4(%rax)
mov    -0x8(%rbp),%rax
movss  0xbc(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0xb8(%rax),%xmm0
movss  %xmm0,0xb8(%rax)
mov    -0x8(%rbp),%rax
movss  0xc4(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0xc0(%rax),%xmm0
movss  %xmm0,0xc0(%rax)
mov    -0x8(%rbp),%rax
movss  0xc8(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0xc4(%rax),%xmm0
movss  %xmm0,0xc4(%rax)
mov    -0x8(%rbp),%rax
movss  0xcc(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0xc8(%rax),%xmm0
movss  %xmm0,0xc8(%rax)
mov    -0x8(%rbp),%rax
movss  0xd4(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0xd0(%rax),%xmm0
movss  %xmm0,0xd0(%rax)
mov    -0x8(%rbp),%rax
movss  0xd8(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0xd4(%rax),%xmm0
movss  %xmm0,0xd4(%rax)
mov    -0x8(%rbp),%rax
movss  0xdc(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0xd8(%rax),%xmm0
movss  %xmm0,0xd8(%rax)
mov    -0x8(%rbp),%rax
movss  0xe4(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0xe0(%rax),%xmm0
movss  %xmm0,0xe0(%rax)
mov    -0x8(%rbp),%rax
movss  0xe8(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0xe4(%rax),%xmm0
movss  %xmm0,0xe4(%rax)
mov    -0x8(%rbp),%rax
movss  0xec(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0xe8(%rax),%xmm0
movss  %xmm0,0xe8(%rax)
mov    -0x8(%rbp),%rax
movss  0xf4(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0xf0(%rax),%xmm0
movss  %xmm0,0xf0(%rax)
mov    -0x8(%rbp),%rax
movss  0xf8(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0xf4(%rax),%xmm0
movss  %xmm0,0xf4(%rax)
mov    -0x8(%rbp),%rax
movss  0xfc(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0xf8(%rax),%xmm0
movss  %xmm0,0xf8(%rax)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1112 <iterate+0x12>
pop    %rbp
ret

x86 assembly (clang, -O2):
<iterate>:
test   %esi,%esi
jle    18d3 <iterate+0x7d3>
sub    $0x60,%rsp
movss  0xc(%rdi),%xmm0
movss  %xmm0,0x44(%rsp)
movss  0x1c(%rdi),%xmm0
movss  %xmm0,0x40(%rsp)
movss  0x2c(%rdi),%xmm0
movss  %xmm0,0x3c(%rsp)
movss  0x3c(%rdi),%xmm0
movss  %xmm0,0x38(%rsp)
movss  0x4c(%rdi),%xmm0
movss  %xmm0,0x34(%rsp)
movss  0x5c(%rdi),%xmm0
movss  %xmm0,0x30(%rsp)
movss  0x6c(%rdi),%xmm0
movss  %xmm0,0x2c(%rsp)
movss  0x7c(%rdi),%xmm0
movss  %xmm0,0x28(%rsp)
movss  0x8c(%rdi),%xmm0
movss  %xmm0,0x24(%rsp)
movss  0x9c(%rdi),%xmm0
movss  %xmm0,0x20(%rsp)
movss  0xac(%rdi),%xmm0
movss  %xmm0,0x1c(%rsp)
movss  0xbc(%rdi),%xmm0
movss  %xmm0,0x18(%rsp)
movss  0xcc(%rdi),%xmm0
movss  %xmm0,0x14(%rsp)
movss  0xdc(%rdi),%xmm0
movss  %xmm0,0x10(%rsp)
movss  0xec(%rdi),%xmm0
movss  %xmm0,0xc(%rsp)
movss  0xfc(%rdi),%xmm0
movss  %xmm0,0x8(%rsp)
movss  (%rdi),%xmm0
movss  %xmm0,0x4(%rsp)
movss  0x4(%rdi),%xmm0
movss  %xmm0,-0x7c(%rsp)
movss  0x8(%rdi),%xmm0
movss  %xmm0,-0x78(%rsp)
movss  0x14(%rdi),%xmm0
movss  %xmm0,-0x74(%rsp)
movss  0x10(%rdi),%xmm0
movss  %xmm0,-0x70(%rsp)
movss  0x18(%rdi),%xmm0
movss  %xmm0,-0x6c(%rsp)
movss  0x24(%rdi),%xmm0
movss  %xmm0,-0x68(%rsp)
movss  0x20(%rdi),%xmm0
movss  %xmm0,-0x64(%rsp)
movss  0x28(%rdi),%xmm0
movss  %xmm0,-0x60(%rsp)
movss  0x34(%rdi),%xmm0
movss  %xmm0,-0x5c(%rsp)
movss  0x30(%rdi),%xmm0
movss  %xmm0,-0x58(%rsp)
movss  0x38(%rdi),%xmm0
movss  %xmm0,-0x54(%rsp)
movss  0x44(%rdi),%xmm0
movss  %xmm0,-0x50(%rsp)
movss  0x40(%rdi),%xmm0
movss  %xmm0,-0x4c(%rsp)
movss  0x48(%rdi),%xmm0
movss  %xmm0,-0x48(%rsp)
movss  0x54(%rdi),%xmm0
movss  %xmm0,-0x44(%rsp)
movss  0x50(%rdi),%xmm0
movss  %xmm0,-0x40(%rsp)
movss  0x58(%rdi),%xmm0
movss  %xmm0,-0x3c(%rsp)
movss  0x64(%rdi),%xmm0
movss  %xmm0,-0x38(%rsp)
movss  0x60(%rdi),%xmm0
movss  %xmm0,-0x34(%rsp)
movss  0x68(%rdi),%xmm0
movss  %xmm0,-0x30(%rsp)
movss  0x74(%rdi),%xmm0
movss  %xmm0,-0x2c(%rsp)
movss  0x70(%rdi),%xmm0
movss  %xmm0,-0x28(%rsp)
movss  0x78(%rdi),%xmm0
movss  %xmm0,-0x24(%rsp)
movss  0x84(%rdi),%xmm0
movss  %xmm0,-0x20(%rsp)
movss  0x80(%rdi),%xmm0
movss  %xmm0,-0x1c(%rsp)
movss  0x88(%rdi),%xmm0
movss  %xmm0,-0x18(%rsp)
movss  0x94(%rdi),%xmm0
movss  %xmm0,-0x14(%rsp)
movss  0x90(%rdi),%xmm0
movss  %xmm0,-0x10(%rsp)
movss  0x98(%rdi),%xmm0
movss  %xmm0,-0xc(%rsp)
movss  0xa4(%rdi),%xmm0
movss  %xmm0,-0x8(%rsp)
movss  0xa0(%rdi),%xmm0
movss  %xmm0,-0x4(%rsp)
movss  0xa8(%rdi),%xmm0
movss  %xmm0,(%rsp)
movss  0xb4(%rdi),%xmm14
movss  0xb0(%rdi),%xmm11
movss  0xb8(%rdi),%xmm4
movss  0xc4(%rdi),%xmm7
movss  0xc0(%rdi),%xmm15
movss  0xc8(%rdi),%xmm5
movss  0xd4(%rdi),%xmm10
movss  0xd0(%rdi),%xmm13
movss  0xd8(%rdi),%xmm8
movss  0xe4(%rdi),%xmm6
movss  0xe0(%rdi),%xmm0
movss  %xmm0,-0x80(%rsp)
movss  0xe8(%rdi),%xmm12
movss  0xf4(%rdi),%xmm2
movss  0xf0(%rdi),%xmm3
movss  0xf8(%rdi),%xmm1
nopl   (%rax)
movss  %xmm3,0x48(%rsp)
movss  %xmm2,0x4c(%rsp)
movss  %xmm11,0x50(%rsp)
movss  %xmm4,0x54(%rsp)
movss  %xmm1,0x58(%rsp)
movss  %xmm7,0x5c(%rsp)
movaps %xmm6,%xmm11
movaps %xmm5,%xmm6
movss  0x4(%rsp),%xmm1
movss  -0x7c(%rsp),%xmm3
addss  %xmm3,%xmm1
movss  %xmm1,0x4(%rsp)
movss  0x5c(%rsp),%xmm7
movaps %xmm11,%xmm6
movss  0x4c(%rsp),%xmm2
movss  0x50(%rsp),%xmm11
movss  0x58(%rsp),%xmm1
movss  0x54(%rsp),%xmm4
movss  -0x78(%rsp),%xmm0
addss  %xmm0,%xmm3
movss  %xmm3,-0x7c(%rsp)
addss  0x44(%rsp),%xmm0
movss  %xmm0,-0x78(%rsp)
movss  -0x70(%rsp),%xmm0
movss  -0x74(%rsp),%xmm3
addss  %xmm3,%xmm0
movss  %xmm0,-0x70(%rsp)
movss  -0x6c(%rsp),%xmm0
addss  %xmm0,%xmm3
movss  %xmm3,-0x74(%rsp)
addss  0x40(%rsp),%xmm0
movss  %xmm0,-0x6c(%rsp)
movss  -0x64(%rsp),%xmm0
movss  -0x68(%rsp),%xmm3
addss  %xmm3,%xmm0
movss  %xmm0,-0x64(%rsp)
movss  -0x60(%rsp),%xmm0
addss  %xmm0,%xmm3
movss  %xmm3,-0x68(%rsp)
addss  0x3c(%rsp),%xmm0
movss  %xmm0,-0x60(%rsp)
movss  -0x58(%rsp),%xmm0
movss  -0x5c(%rsp),%xmm3
addss  %xmm3,%xmm0
movss  %xmm0,-0x58(%rsp)
movss  -0x54(%rsp),%xmm0
addss  %xmm0,%xmm3
movss  %xmm3,-0x5c(%rsp)
addss  0x38(%rsp),%xmm0
movss  %xmm0,-0x54(%rsp)
movss  -0x4c(%rsp),%xmm0
movss  -0x50(%rsp),%xmm3
addss  %xmm3,%xmm0
movss  %xmm0,-0x4c(%rsp)
movss  -0x48(%rsp),%xmm0
addss  %xmm0,%xmm3
movss  %xmm3,-0x50(%rsp)
addss  0x34(%rsp),%xmm0
movss  %xmm0,-0x48(%rsp)
movss  -0x40(%rsp),%xmm0
movss  -0x44(%rsp),%xmm3
addss  %xmm3,%xmm0
movss  %xmm0,-0x40(%rsp)
movss  -0x3c(%rsp),%xmm0
addss  %xmm0,%xmm3
movss  %xmm3,-0x44(%rsp)
addss  0x30(%rsp),%xmm0
movss  %xmm0,-0x3c(%rsp)
movss  -0x34(%rsp),%xmm0
movss  -0x38(%rsp),%xmm3
addss  %xmm3,%xmm0
movss  %xmm0,-0x34(%rsp)
movss  -0x30(%rsp),%xmm0
addss  %xmm0,%xmm3
movss  %xmm3,-0x38(%rsp)
addss  0x2c(%rsp),%xmm0
movss  %xmm0,-0x30(%rsp)
movss  -0x28(%rsp),%xmm0
movss  -0x2c(%rsp),%xmm3
addss  %xmm3,%xmm0
movss  %xmm0,-0x28(%rsp)
movss  -0x24(%rsp),%xmm0
addss  %xmm0,%xmm3
movss  %xmm3,-0x2c(%rsp)
addss  0x28(%rsp),%xmm0
movss  %xmm0,-0x24(%rsp)
movss  -0x1c(%rsp),%xmm0
movss  -0x20(%rsp),%xmm3
addss  %xmm3,%xmm0
movss  %xmm0,-0x1c(%rsp)
movss  -0x18(%rsp),%xmm0
addss  %xmm0,%xmm3
movss  %xmm3,-0x20(%rsp)
addss  0x24(%rsp),%xmm0
movss  %xmm0,-0x18(%rsp)
movss  -0x10(%rsp),%xmm0
movss  -0x14(%rsp),%xmm3
addss  %xmm3,%xmm0
movss  %xmm0,-0x10(%rsp)
movss  -0xc(%rsp),%xmm0
addss  %xmm0,%xmm3
movss  %xmm3,-0x14(%rsp)
addss  0x20(%rsp),%xmm0
movss  %xmm0,-0xc(%rsp)
movss  -0x4(%rsp),%xmm0
movss  -0x8(%rsp),%xmm9
addss  %xmm9,%xmm0
movss  %xmm0,-0x4(%rsp)
movss  (%rsp),%xmm0
addss  %xmm0,%xmm9
movss  %xmm9,-0x8(%rsp)
addss  0x1c(%rsp),%xmm0
movss  %xmm0,(%rsp)
addss  %xmm14,%xmm11
addss  %xmm4,%xmm14
addss  0x18(%rsp),%xmm4
addss  %xmm7,%xmm15
addss  %xmm5,%xmm7
addss  0x14(%rsp),%xmm5
addss  %xmm10,%xmm13
addss  %xmm8,%xmm10
addss  0x10(%rsp),%xmm8
movss  -0x80(%rsp),%xmm0
addss  %xmm6,%xmm0
movss  %xmm0,-0x80(%rsp)
addss  %xmm12,%xmm6
addss  0xc(%rsp),%xmm12
movss  0x48(%rsp),%xmm9
addss  %xmm2,%xmm9
movaps %xmm9,%xmm3
addss  %xmm1,%xmm2
addss  0x8(%rsp),%xmm1
add    $0xffffffff,%esi
jne    13e0 <iterate+0x2e0>
movss  -0x7c(%rsp),%xmm0
movss  %xmm0,0x4(%rdi)
movss  0x4(%rsp),%xmm0
movss  %xmm0,(%rdi)
movss  -0x78(%rsp),%xmm0
movss  %xmm0,0x8(%rdi)
movss  -0x74(%rsp),%xmm0
movss  %xmm0,0x14(%rdi)
movss  -0x70(%rsp),%xmm0
movss  %xmm0,0x10(%rdi)
movss  -0x6c(%rsp),%xmm0
movss  %xmm0,0x18(%rdi)
movss  -0x68(%rsp),%xmm0
movss  %xmm0,0x24(%rdi)
movss  -0x64(%rsp),%xmm0
movss  %xmm0,0x20(%rdi)
movss  -0x60(%rsp),%xmm0
movss  %xmm0,0x28(%rdi)
movss  -0x5c(%rsp),%xmm0
movss  %xmm0,0x34(%rdi)
movss  -0x58(%rsp),%xmm0
movss  %xmm0,0x30(%rdi)
movss  -0x54(%rsp),%xmm0
movss  %xmm0,0x38(%rdi)
movss  -0x50(%rsp),%xmm0
movss  %xmm0,0x44(%rdi)
movss  -0x4c(%rsp),%xmm0
movss  %xmm0,0x40(%rdi)
movss  -0x48(%rsp),%xmm0
movss  %xmm0,0x48(%rdi)
movss  -0x44(%rsp),%xmm0
movss  %xmm0,0x54(%rdi)
movss  -0x40(%rsp),%xmm0
movss  %xmm0,0x50(%rdi)
movss  -0x3c(%rsp),%xmm0
movss  %xmm0,0x58(%rdi)
movss  -0x38(%rsp),%xmm0
movss  %xmm0,0x64(%rdi)
movss  -0x34(%rsp),%xmm0
movss  %xmm0,0x60(%rdi)
movss  -0x30(%rsp),%xmm0
movss  %xmm0,0x68(%rdi)
movss  -0x2c(%rsp),%xmm0
movss  %xmm0,0x74(%rdi)
movss  -0x28(%rsp),%xmm0
movss  %xmm0,0x70(%rdi)
movss  -0x24(%rsp),%xmm0
movss  %xmm0,0x78(%rdi)
movss  -0x20(%rsp),%xmm0
movss  %xmm0,0x84(%rdi)
movss  -0x1c(%rsp),%xmm0
movss  %xmm0,0x80(%rdi)
movss  -0x18(%rsp),%xmm0
movss  %xmm0,0x88(%rdi)
movss  -0x14(%rsp),%xmm0
movss  %xmm0,0x94(%rdi)
movss  -0x10(%rsp),%xmm0
movss  %xmm0,0x90(%rdi)
movss  -0xc(%rsp),%xmm0
movss  %xmm0,0x98(%rdi)
movss  -0x8(%rsp),%xmm0
movss  %xmm0,0xa4(%rdi)
movss  -0x4(%rsp),%xmm0
movss  %xmm0,0xa0(%rdi)
movss  (%rsp),%xmm0
movss  %xmm0,0xa8(%rdi)
movss  %xmm14,0xb4(%rdi)
movss  %xmm11,0xb0(%rdi)
movss  %xmm4,0xb8(%rdi)
movss  %xmm7,0xc4(%rdi)
movss  %xmm15,0xc0(%rdi)
movss  %xmm5,0xc8(%rdi)
movss  %xmm10,0xd4(%rdi)
movss  %xmm13,0xd0(%rdi)
movss  %xmm8,0xd8(%rdi)
movss  %xmm6,0xe4(%rdi)
movss  -0x80(%rsp),%xmm0
movss  %xmm0,0xe0(%rdi)
movss  %xmm12,0xe8(%rdi)
movss  %xmm2,0xf4(%rdi)
movss  %xmm3,0xf0(%rdi)
movss  %xmm1,0xf8(%rdi)
add    $0x60,%rsp
ret

LLVM IR (-O0):
define void @iterate([4 x [4 x float]]* %0, i32 %1) {
%3 = alloca [4 x [4 x float]]*
%4 = alloca i32
%5 = alloca i32
store [4 x [4 x float]]* %0, [4 x [4 x float]]** %3
store i32 %1, i32* %4
store i32 0, i32* %5
br label %6
6: ; preds = %539, %2
%7 = load i32, i32* %5
%8 = load i32, i32* %4
%9 = icmp slt i32 %7, %8
br i1 %9, label %10, label %542
10: ; preds = %6
%11 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%12 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %11, i64 0
%13 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %12, i64 0, i64 0
%14 = getelementptr inbounds [4 x float], [4 x float]* %13, i64 0, i64 1
%15 = load float, float* %14
%16 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%17 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %16, i64 0
%18 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %17, i64 0, i64 0
%19 = getelementptr inbounds [4 x float], [4 x float]* %18, i64 0, i64 0
%20 = load float, float* %19
%21 = fadd float %20, %15
store float %21, float* %19
%22 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%23 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %22, i64 0
%24 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %23, i64 0, i64 0
%25 = getelementptr inbounds [4 x float], [4 x float]* %24, i64 0, i64 2
%26 = load float, float* %25
%27 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%28 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %27, i64 0
%29 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %28, i64 0, i64 0
%30 = getelementptr inbounds [4 x float], [4 x float]* %29, i64 0, i64 1
%31 = load float, float* %30
%32 = fadd float %31, %26
store float %32, float* %30
%33 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%34 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %33, i64 0
%35 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %34, i64 0, i64 0
%36 = getelementptr inbounds [4 x float], [4 x float]* %35, i64 0, i64 3
%37 = load float, float* %36
%38 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%39 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %38, i64 0
%40 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %39, i64 0, i64 0
%41 = getelementptr inbounds [4 x float], [4 x float]* %40, i64 0, i64 2
%42 = load float, float* %41
%43 = fadd float %42, %37
store float %43, float* %41
%44 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%45 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %44, i64 0
%46 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %45, i64 0, i64 1
%47 = getelementptr inbounds [4 x float], [4 x float]* %46, i64 0, i64 1
%48 = load float, float* %47
%49 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%50 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %49, i64 0
%51 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %50, i64 0, i64 1
%52 = getelementptr inbounds [4 x float], [4 x float]* %51, i64 0, i64 0
%53 = load float, float* %52
%54 = fadd float %53, %48
store float %54, float* %52
%55 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%56 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %55, i64 0
%57 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %56, i64 0, i64 1
%58 = getelementptr inbounds [4 x float], [4 x float]* %57, i64 0, i64 2
%59 = load float, float* %58
%60 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%61 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %60, i64 0
%62 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %61, i64 0, i64 1
%63 = getelementptr inbounds [4 x float], [4 x float]* %62, i64 0, i64 1
%64 = load float, float* %63
%65 = fadd float %64, %59
store float %65, float* %63
%66 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%67 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %66, i64 0
%68 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %67, i64 0, i64 1
%69 = getelementptr inbounds [4 x float], [4 x float]* %68, i64 0, i64 3
%70 = load float, float* %69
%71 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%72 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %71, i64 0
%73 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %72, i64 0, i64 1
%74 = getelementptr inbounds [4 x float], [4 x float]* %73, i64 0, i64 2
%75 = load float, float* %74
%76 = fadd float %75, %70
store float %76, float* %74
%77 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%78 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %77, i64 0
%79 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %78, i64 0, i64 2
%80 = getelementptr inbounds [4 x float], [4 x float]* %79, i64 0, i64 1
%81 = load float, float* %80
%82 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%83 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %82, i64 0
%84 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %83, i64 0, i64 2
%85 = getelementptr inbounds [4 x float], [4 x float]* %84, i64 0, i64 0
%86 = load float, float* %85
%87 = fadd float %86, %81
store float %87, float* %85
%88 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%89 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %88, i64 0
%90 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %89, i64 0, i64 2
%91 = getelementptr inbounds [4 x float], [4 x float]* %90, i64 0, i64 2
%92 = load float, float* %91
%93 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%94 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %93, i64 0
%95 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %94, i64 0, i64 2
%96 = getelementptr inbounds [4 x float], [4 x float]* %95, i64 0, i64 1
%97 = load float, float* %96
%98 = fadd float %97, %92
store float %98, float* %96
%99 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%100 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %99, i64 0
%101 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %100, i64 0, i64 2
%102 = getelementptr inbounds [4 x float], [4 x float]* %101, i64 0, i64 3
%103 = load float, float* %102
%104 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%105 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %104, i64 0
%106 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %105, i64 0, i64 2
%107 = getelementptr inbounds [4 x float], [4 x float]* %106, i64 0, i64 2
%108 = load float, float* %107
%109 = fadd float %108, %103
store float %109, float* %107
%110 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%111 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %110, i64 0
%112 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %111, i64 0, i64 3
%113 = getelementptr inbounds [4 x float], [4 x float]* %112, i64 0, i64 1
%114 = load float, float* %113
%115 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%116 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %115, i64 0
%117 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %116, i64 0, i64 3
%118 = getelementptr inbounds [4 x float], [4 x float]* %117, i64 0, i64 0
%119 = load float, float* %118
%120 = fadd float %119, %114
store float %120, float* %118
%121 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%122 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %121, i64 0
%123 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %122, i64 0, i64 3
%124 = getelementptr inbounds [4 x float], [4 x float]* %123, i64 0, i64 2
%125 = load float, float* %124
%126 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%127 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %126, i64 0
%128 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %127, i64 0, i64 3
%129 = getelementptr inbounds [4 x float], [4 x float]* %128, i64 0, i64 1
%130 = load float, float* %129
%131 = fadd float %130, %125
store float %131, float* %129
%132 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%133 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %132, i64 0
%134 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %133, i64 0, i64 3
%135 = getelementptr inbounds [4 x float], [4 x float]* %134, i64 0, i64 3
%136 = load float, float* %135
%137 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%138 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %137, i64 0
%139 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %138, i64 0, i64 3
%140 = getelementptr inbounds [4 x float], [4 x float]* %139, i64 0, i64 2
%141 = load float, float* %140
%142 = fadd float %141, %136
store float %142, float* %140
%143 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%144 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %143, i64 1
%145 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %144, i64 0, i64 0
%146 = getelementptr inbounds [4 x float], [4 x float]* %145, i64 0, i64 1
%147 = load float, float* %146
%148 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%149 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %148, i64 1
%150 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %149, i64 0, i64 0
%151 = getelementptr inbounds [4 x float], [4 x float]* %150, i64 0, i64 0
%152 = load float, float* %151
%153 = fadd float %152, %147
store float %153, float* %151
%154 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%155 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %154, i64 1
%156 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %155, i64 0, i64 0
%157 = getelementptr inbounds [4 x float], [4 x float]* %156, i64 0, i64 2
%158 = load float, float* %157
%159 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%160 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %159, i64 1
%161 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %160, i64 0, i64 0
%162 = getelementptr inbounds [4 x float], [4 x float]* %161, i64 0, i64 1
%163 = load float, float* %162
%164 = fadd float %163, %158
store float %164, float* %162
%165 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%166 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %165, i64 1
%167 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %166, i64 0, i64 0
%168 = getelementptr inbounds [4 x float], [4 x float]* %167, i64 0, i64 3
%169 = load float, float* %168
%170 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%171 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %170, i64 1
%172 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %171, i64 0, i64 0
%173 = getelementptr inbounds [4 x float], [4 x float]* %172, i64 0, i64 2
%174 = load float, float* %173
%175 = fadd float %174, %169
store float %175, float* %173
%176 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%177 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %176, i64 1
%178 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %177, i64 0, i64 1
%179 = getelementptr inbounds [4 x float], [4 x float]* %178, i64 0, i64 1
%180 = load float, float* %179
%181 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%182 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %181, i64 1
%183 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %182, i64 0, i64 1
%184 = getelementptr inbounds [4 x float], [4 x float]* %183, i64 0, i64 0
%185 = load float, float* %184
%186 = fadd float %185, %180
store float %186, float* %184
%187 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%188 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %187, i64 1
%189 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %188, i64 0, i64 1
%190 = getelementptr inbounds [4 x float], [4 x float]* %189, i64 0, i64 2
%191 = load float, float* %190
%192 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%193 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %192, i64 1
%194 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %193, i64 0, i64 1
%195 = getelementptr inbounds [4 x float], [4 x float]* %194, i64 0, i64 1
%196 = load float, float* %195
%197 = fadd float %196, %191
store float %197, float* %195
%198 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%199 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %198, i64 1
%200 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %199, i64 0, i64 1
%201 = getelementptr inbounds [4 x float], [4 x float]* %200, i64 0, i64 3
%202 = load float, float* %201
%203 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%204 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %203, i64 1
%205 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %204, i64 0, i64 1
%206 = getelementptr inbounds [4 x float], [4 x float]* %205, i64 0, i64 2
%207 = load float, float* %206
%208 = fadd float %207, %202
store float %208, float* %206
%209 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%210 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %209, i64 1
%211 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %210, i64 0, i64 2
%212 = getelementptr inbounds [4 x float], [4 x float]* %211, i64 0, i64 1
%213 = load float, float* %212
%214 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%215 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %214, i64 1
%216 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %215, i64 0, i64 2
%217 = getelementptr inbounds [4 x float], [4 x float]* %216, i64 0, i64 0
%218 = load float, float* %217
%219 = fadd float %218, %213
store float %219, float* %217
%220 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%221 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %220, i64 1
%222 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %221, i64 0, i64 2
%223 = getelementptr inbounds [4 x float], [4 x float]* %222, i64 0, i64 2
%224 = load float, float* %223
%225 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%226 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %225, i64 1
%227 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %226, i64 0, i64 2
%228 = getelementptr inbounds [4 x float], [4 x float]* %227, i64 0, i64 1
%229 = load float, float* %228
%230 = fadd float %229, %224
store float %230, float* %228
%231 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%232 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %231, i64 1
%233 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %232, i64 0, i64 2
%234 = getelementptr inbounds [4 x float], [4 x float]* %233, i64 0, i64 3
%235 = load float, float* %234
%236 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%237 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %236, i64 1
%238 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %237, i64 0, i64 2
%239 = getelementptr inbounds [4 x float], [4 x float]* %238, i64 0, i64 2
%240 = load float, float* %239
%241 = fadd float %240, %235
store float %241, float* %239
%242 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%243 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %242, i64 1
%244 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %243, i64 0, i64 3
%245 = getelementptr inbounds [4 x float], [4 x float]* %244, i64 0, i64 1
%246 = load float, float* %245
%247 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%248 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %247, i64 1
%249 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %248, i64 0, i64 3
%250 = getelementptr inbounds [4 x float], [4 x float]* %249, i64 0, i64 0
%251 = load float, float* %250
%252 = fadd float %251, %246
store float %252, float* %250
%253 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%254 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %253, i64 1
%255 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %254, i64 0, i64 3
%256 = getelementptr inbounds [4 x float], [4 x float]* %255, i64 0, i64 2
%257 = load float, float* %256
%258 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%259 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %258, i64 1
%260 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %259, i64 0, i64 3
%261 = getelementptr inbounds [4 x float], [4 x float]* %260, i64 0, i64 1
%262 = load float, float* %261
%263 = fadd float %262, %257
store float %263, float* %261
%264 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%265 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %264, i64 1
%266 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %265, i64 0, i64 3
%267 = getelementptr inbounds [4 x float], [4 x float]* %266, i64 0, i64 3
%268 = load float, float* %267
%269 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%270 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %269, i64 1
%271 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %270, i64 0, i64 3
%272 = getelementptr inbounds [4 x float], [4 x float]* %271, i64 0, i64 2
%273 = load float, float* %272
%274 = fadd float %273, %268
store float %274, float* %272
%275 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%276 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %275, i64 2
%277 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %276, i64 0, i64 0
%278 = getelementptr inbounds [4 x float], [4 x float]* %277, i64 0, i64 1
%279 = load float, float* %278
%280 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%281 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %280, i64 2
%282 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %281, i64 0, i64 0
%283 = getelementptr inbounds [4 x float], [4 x float]* %282, i64 0, i64 0
%284 = load float, float* %283
%285 = fadd float %284, %279
store float %285, float* %283
%286 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%287 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %286, i64 2
%288 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %287, i64 0, i64 0
%289 = getelementptr inbounds [4 x float], [4 x float]* %288, i64 0, i64 2
%290 = load float, float* %289
%291 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%292 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %291, i64 2
%293 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %292, i64 0, i64 0
%294 = getelementptr inbounds [4 x float], [4 x float]* %293, i64 0, i64 1
%295 = load float, float* %294
%296 = fadd float %295, %290
store float %296, float* %294
%297 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%298 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %297, i64 2
%299 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %298, i64 0, i64 0
%300 = getelementptr inbounds [4 x float], [4 x float]* %299, i64 0, i64 3
%301 = load float, float* %300
%302 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%303 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %302, i64 2
%304 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %303, i64 0, i64 0
%305 = getelementptr inbounds [4 x float], [4 x float]* %304, i64 0, i64 2
%306 = load float, float* %305
%307 = fadd float %306, %301
store float %307, float* %305
%308 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%309 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %308, i64 2
%310 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %309, i64 0, i64 1
%311 = getelementptr inbounds [4 x float], [4 x float]* %310, i64 0, i64 1
%312 = load float, float* %311
%313 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%314 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %313, i64 2
%315 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %314, i64 0, i64 1
%316 = getelementptr inbounds [4 x float], [4 x float]* %315, i64 0, i64 0
%317 = load float, float* %316
%318 = fadd float %317, %312
store float %318, float* %316
%319 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%320 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %319, i64 2
%321 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %320, i64 0, i64 1
%322 = getelementptr inbounds [4 x float], [4 x float]* %321, i64 0, i64 2
%323 = load float, float* %322
%324 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%325 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %324, i64 2
%326 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %325, i64 0, i64 1
%327 = getelementptr inbounds [4 x float], [4 x float]* %326, i64 0, i64 1
%328 = load float, float* %327
%329 = fadd float %328, %323
store float %329, float* %327
%330 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%331 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %330, i64 2
%332 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %331, i64 0, i64 1
%333 = getelementptr inbounds [4 x float], [4 x float]* %332, i64 0, i64 3
%334 = load float, float* %333
%335 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%336 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %335, i64 2
%337 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %336, i64 0, i64 1
%338 = getelementptr inbounds [4 x float], [4 x float]* %337, i64 0, i64 2
%339 = load float, float* %338
%340 = fadd float %339, %334
store float %340, float* %338
%341 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%342 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %341, i64 2
%343 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %342, i64 0, i64 2
%344 = getelementptr inbounds [4 x float], [4 x float]* %343, i64 0, i64 1
%345 = load float, float* %344
%346 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%347 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %346, i64 2
%348 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %347, i64 0, i64 2
%349 = getelementptr inbounds [4 x float], [4 x float]* %348, i64 0, i64 0
%350 = load float, float* %349
%351 = fadd float %350, %345
store float %351, float* %349
%352 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%353 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %352, i64 2
%354 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %353, i64 0, i64 2
%355 = getelementptr inbounds [4 x float], [4 x float]* %354, i64 0, i64 2
%356 = load float, float* %355
%357 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%358 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %357, i64 2
%359 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %358, i64 0, i64 2
%360 = getelementptr inbounds [4 x float], [4 x float]* %359, i64 0, i64 1
%361 = load float, float* %360
%362 = fadd float %361, %356
store float %362, float* %360
%363 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%364 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %363, i64 2
%365 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %364, i64 0, i64 2
%366 = getelementptr inbounds [4 x float], [4 x float]* %365, i64 0, i64 3
%367 = load float, float* %366
%368 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%369 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %368, i64 2
%370 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %369, i64 0, i64 2
%371 = getelementptr inbounds [4 x float], [4 x float]* %370, i64 0, i64 2
%372 = load float, float* %371
%373 = fadd float %372, %367
store float %373, float* %371
%374 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%375 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %374, i64 2
%376 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %375, i64 0, i64 3
%377 = getelementptr inbounds [4 x float], [4 x float]* %376, i64 0, i64 1
%378 = load float, float* %377
%379 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%380 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %379, i64 2
%381 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %380, i64 0, i64 3
%382 = getelementptr inbounds [4 x float], [4 x float]* %381, i64 0, i64 0
%383 = load float, float* %382
%384 = fadd float %383, %378
store float %384, float* %382
%385 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%386 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %385, i64 2
%387 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %386, i64 0, i64 3
%388 = getelementptr inbounds [4 x float], [4 x float]* %387, i64 0, i64 2
%389 = load float, float* %388
%390 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%391 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %390, i64 2
%392 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %391, i64 0, i64 3
%393 = getelementptr inbounds [4 x float], [4 x float]* %392, i64 0, i64 1
%394 = load float, float* %393
%395 = fadd float %394, %389
store float %395, float* %393
%396 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%397 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %396, i64 2
%398 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %397, i64 0, i64 3
%399 = getelementptr inbounds [4 x float], [4 x float]* %398, i64 0, i64 3
%400 = load float, float* %399
%401 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%402 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %401, i64 2
%403 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %402, i64 0, i64 3
%404 = getelementptr inbounds [4 x float], [4 x float]* %403, i64 0, i64 2
%405 = load float, float* %404
%406 = fadd float %405, %400
store float %406, float* %404
%407 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%408 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %407, i64 3
%409 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %408, i64 0, i64 0
%410 = getelementptr inbounds [4 x float], [4 x float]* %409, i64 0, i64 1
%411 = load float, float* %410
%412 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%413 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %412, i64 3
%414 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %413, i64 0, i64 0
%415 = getelementptr inbounds [4 x float], [4 x float]* %414, i64 0, i64 0
%416 = load float, float* %415
%417 = fadd float %416, %411
store float %417, float* %415
%418 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%419 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %418, i64 3
%420 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %419, i64 0, i64 0
%421 = getelementptr inbounds [4 x float], [4 x float]* %420, i64 0, i64 2
%422 = load float, float* %421
%423 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%424 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %423, i64 3
%425 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %424, i64 0, i64 0
%426 = getelementptr inbounds [4 x float], [4 x float]* %425, i64 0, i64 1
%427 = load float, float* %426
%428 = fadd float %427, %422
store float %428, float* %426
%429 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%430 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %429, i64 3
%431 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %430, i64 0, i64 0
%432 = getelementptr inbounds [4 x float], [4 x float]* %431, i64 0, i64 3
%433 = load float, float* %432
%434 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%435 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %434, i64 3
%436 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %435, i64 0, i64 0
%437 = getelementptr inbounds [4 x float], [4 x float]* %436, i64 0, i64 2
%438 = load float, float* %437
%439 = fadd float %438, %433
store float %439, float* %437
%440 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%441 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %440, i64 3
%442 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %441, i64 0, i64 1
%443 = getelementptr inbounds [4 x float], [4 x float]* %442, i64 0, i64 1
%444 = load float, float* %443
%445 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%446 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %445, i64 3
%447 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %446, i64 0, i64 1
%448 = getelementptr inbounds [4 x float], [4 x float]* %447, i64 0, i64 0
%449 = load float, float* %448
%450 = fadd float %449, %444
store float %450, float* %448
%451 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%452 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %451, i64 3
%453 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %452, i64 0, i64 1
%454 = getelementptr inbounds [4 x float], [4 x float]* %453, i64 0, i64 2
%455 = load float, float* %454
%456 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%457 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %456, i64 3
%458 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %457, i64 0, i64 1
%459 = getelementptr inbounds [4 x float], [4 x float]* %458, i64 0, i64 1
%460 = load float, float* %459
%461 = fadd float %460, %455
store float %461, float* %459
%462 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%463 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %462, i64 3
%464 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %463, i64 0, i64 1
%465 = getelementptr inbounds [4 x float], [4 x float]* %464, i64 0, i64 3
%466 = load float, float* %465
%467 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%468 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %467, i64 3
%469 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %468, i64 0, i64 1
%470 = getelementptr inbounds [4 x float], [4 x float]* %469, i64 0, i64 2
%471 = load float, float* %470
%472 = fadd float %471, %466
store float %472, float* %470
%473 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%474 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %473, i64 3
%475 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %474, i64 0, i64 2
%476 = getelementptr inbounds [4 x float], [4 x float]* %475, i64 0, i64 1
%477 = load float, float* %476
%478 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%479 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %478, i64 3
%480 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %479, i64 0, i64 2
%481 = getelementptr inbounds [4 x float], [4 x float]* %480, i64 0, i64 0
%482 = load float, float* %481
%483 = fadd float %482, %477
store float %483, float* %481
%484 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%485 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %484, i64 3
%486 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %485, i64 0, i64 2
%487 = getelementptr inbounds [4 x float], [4 x float]* %486, i64 0, i64 2
%488 = load float, float* %487
%489 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%490 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %489, i64 3
%491 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %490, i64 0, i64 2
%492 = getelementptr inbounds [4 x float], [4 x float]* %491, i64 0, i64 1
%493 = load float, float* %492
%494 = fadd float %493, %488
store float %494, float* %492
%495 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%496 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %495, i64 3
%497 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %496, i64 0, i64 2
%498 = getelementptr inbounds [4 x float], [4 x float]* %497, i64 0, i64 3
%499 = load float, float* %498
%500 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%501 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %500, i64 3
%502 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %501, i64 0, i64 2
%503 = getelementptr inbounds [4 x float], [4 x float]* %502, i64 0, i64 2
%504 = load float, float* %503
%505 = fadd float %504, %499
store float %505, float* %503
%506 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%507 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %506, i64 3
%508 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %507, i64 0, i64 3
%509 = getelementptr inbounds [4 x float], [4 x float]* %508, i64 0, i64 1
%510 = load float, float* %509
%511 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%512 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %511, i64 3
%513 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %512, i64 0, i64 3
%514 = getelementptr inbounds [4 x float], [4 x float]* %513, i64 0, i64 0
%515 = load float, float* %514
%516 = fadd float %515, %510
store float %516, float* %514
%517 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%518 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %517, i64 3
%519 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %518, i64 0, i64 3
%520 = getelementptr inbounds [4 x float], [4 x float]* %519, i64 0, i64 2
%521 = load float, float* %520
%522 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%523 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %522, i64 3
%524 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %523, i64 0, i64 3
%525 = getelementptr inbounds [4 x float], [4 x float]* %524, i64 0, i64 1
%526 = load float, float* %525
%527 = fadd float %526, %521
store float %527, float* %525
%528 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%529 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %528, i64 3
%530 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %529, i64 0, i64 3
%531 = getelementptr inbounds [4 x float], [4 x float]* %530, i64 0, i64 3
%532 = load float, float* %531
%533 = load [4 x [4 x float]]*, [4 x [4 x float]]** %3
%534 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %533, i64 3
%535 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %534, i64 0, i64 3
%536 = getelementptr inbounds [4 x float], [4 x float]* %535, i64 0, i64 2
%537 = load float, float* %536
%538 = fadd float %537, %532
store float %538, float* %536
br label %539
539: ; preds = %10
%540 = load i32, i32* %5
%541 = add nsw i32 %540, 1
store i32 %541, i32* %5
br label %6
542: ; preds = %6
ret void
}

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