int main(int argc, char *argv[]) {
  int A[4][4], B[4][4],
      C[4][4] = {{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}};
  unsigned int n_iter = 10000000, i, j;
  for (i = 0; i < 4; i++) {
    for (j = 0; j < 4; j++) {
      A[i][j] = rand();
      B[i][j] = rand();
    }
  }
  if (argc > 1) {
    n_iter = atoi(argv[1]);
  }
  ({
    int iter;
    int i, j, k;
    for (iter = 0; iter < (n_iter); iter++) {
      ({
        ({
          ({
            (C)[(0)][(0)] = (C)[(0)][(0)] + (A)[(0)][0] * (B)[0][(0)];
            (C)[(0)][(0)] = (C)[(0)][(0)] + (A)[(0)][1] * (B)[1][(0)];
            (C)[(0)][(0)] = (C)[(0)][(0)] + (A)[(0)][2] * (B)[2][(0)];
            (C)[(0)][(0)] = (C)[(0)][(0)] + (A)[(0)][3] * (B)[3][(0)];
          });
          ({
            (C)[(0)][(1)] = (C)[(0)][(1)] + (A)[(0)][0] * (B)[0][(1)];
            (C)[(0)][(1)] = (C)[(0)][(1)] + (A)[(0)][1] * (B)[1][(1)];
            (C)[(0)][(1)] = (C)[(0)][(1)] + (A)[(0)][2] * (B)[2][(1)];
            (C)[(0)][(1)] = (C)[(0)][(1)] + (A)[(0)][3] * (B)[3][(1)];
          });
          ({
            (C)[(0)][(2)] = (C)[(0)][(2)] + (A)[(0)][0] * (B)[0][(2)];
            (C)[(0)][(2)] = (C)[(0)][(2)] + (A)[(0)][1] * (B)[1][(2)];
            (C)[(0)][(2)] = (C)[(0)][(2)] + (A)[(0)][2] * (B)[2][(2)];
            (C)[(0)][(2)] = (C)[(0)][(2)] + (A)[(0)][3] * (B)[3][(2)];
          });
          ({
            (C)[(0)][(3)] = (C)[(0)][(3)] + (A)[(0)][0] * (B)[0][(3)];
            (C)[(0)][(3)] = (C)[(0)][(3)] + (A)[(0)][1] * (B)[1][(3)];
            (C)[(0)][(3)] = (C)[(0)][(3)] + (A)[(0)][2] * (B)[2][(3)];
            (C)[(0)][(3)] = (C)[(0)][(3)] + (A)[(0)][3] * (B)[3][(3)];
          });
        });
        ({
          ({
            (C)[(1)][(0)] = (C)[(1)][(0)] + (A)[(1)][0] * (B)[0][(0)];
            (C)[(1)][(0)] = (C)[(1)][(0)] + (A)[(1)][1] * (B)[1][(0)];
            (C)[(1)][(0)] = (C)[(1)][(0)] + (A)[(1)][2] * (B)[2][(0)];
            (C)[(1)][(0)] = (C)[(1)][(0)] + (A)[(1)][3] * (B)[3][(0)];
          });
          ({
            (C)[(1)][(1)] = (C)[(1)][(1)] + (A)[(1)][0] * (B)[0][(1)];
            (C)[(1)][(1)] = (C)[(1)][(1)] + (A)[(1)][1] * (B)[1][(1)];
            (C)[(1)][(1)] = (C)[(1)][(1)] + (A)[(1)][2] * (B)[2][(1)];
            (C)[(1)][(1)] = (C)[(1)][(1)] + (A)[(1)][3] * (B)[3][(1)];
          });
          ({
            (C)[(1)][(2)] = (C)[(1)][(2)] + (A)[(1)][0] * (B)[0][(2)];
            (C)[(1)][(2)] = (C)[(1)][(2)] + (A)[(1)][1] * (B)[1][(2)];
            (C)[(1)][(2)] = (C)[(1)][(2)] + (A)[(1)][2] * (B)[2][(2)];
            (C)[(1)][(2)] = (C)[(1)][(2)] + (A)[(1)][3] * (B)[3][(2)];
          });
          ({
            (C)[(1)][(3)] = (C)[(1)][(3)] + (A)[(1)][0] * (B)[0][(3)];
            (C)[(1)][(3)] = (C)[(1)][(3)] + (A)[(1)][1] * (B)[1][(3)];
            (C)[(1)][(3)] = (C)[(1)][(3)] + (A)[(1)][2] * (B)[2][(3)];
            (C)[(1)][(3)] = (C)[(1)][(3)] + (A)[(1)][3] * (B)[3][(3)];
          });
        });
        ({
          ({
            (C)[(2)][(0)] = (C)[(2)][(0)] + (A)[(2)][0] * (B)[0][(0)];
            (C)[(2)][(0)] = (C)[(2)][(0)] + (A)[(2)][1] * (B)[1][(0)];
            (C)[(2)][(0)] = (C)[(2)][(0)] + (A)[(2)][2] * (B)[2][(0)];
            (C)[(2)][(0)] = (C)[(2)][(0)] + (A)[(2)][3] * (B)[3][(0)];
          });
          ({
            (C)[(2)][(1)] = (C)[(2)][(1)] + (A)[(2)][0] * (B)[0][(1)];
            (C)[(2)][(1)] = (C)[(2)][(1)] + (A)[(2)][1] * (B)[1][(1)];
            (C)[(2)][(1)] = (C)[(2)][(1)] + (A)[(2)][2] * (B)[2][(1)];
            (C)[(2)][(1)] = (C)[(2)][(1)] + (A)[(2)][3] * (B)[3][(1)];
          });
          ({
            (C)[(2)][(2)] = (C)[(2)][(2)] + (A)[(2)][0] * (B)[0][(2)];
            (C)[(2)][(2)] = (C)[(2)][(2)] + (A)[(2)][1] * (B)[1][(2)];
            (C)[(2)][(2)] = (C)[(2)][(2)] + (A)[(2)][2] * (B)[2][(2)];
            (C)[(2)][(2)] = (C)[(2)][(2)] + (A)[(2)][3] * (B)[3][(2)];
          });
          ({
            (C)[(2)][(3)] = (C)[(2)][(3)] + (A)[(2)][0] * (B)[0][(3)];
            (C)[(2)][(3)] = (C)[(2)][(3)] + (A)[(2)][1] * (B)[1][(3)];
            (C)[(2)][(3)] = (C)[(2)][(3)] + (A)[(2)][2] * (B)[2][(3)];
            (C)[(2)][(3)] = (C)[(2)][(3)] + (A)[(2)][3] * (B)[3][(3)];
          });
        });
        ({
          ({
            (C)[(3)][(0)] = (C)[(3)][(0)] + (A)[(3)][0] * (B)[0][(0)];
            (C)[(3)][(0)] = (C)[(3)][(0)] + (A)[(3)][1] * (B)[1][(0)];
            (C)[(3)][(0)] = (C)[(3)][(0)] + (A)[(3)][2] * (B)[2][(0)];
            (C)[(3)][(0)] = (C)[(3)][(0)] + (A)[(3)][3] * (B)[3][(0)];
          });
          ({
            (C)[(3)][(1)] = (C)[(3)][(1)] + (A)[(3)][0] * (B)[0][(1)];
            (C)[(3)][(1)] = (C)[(3)][(1)] + (A)[(3)][1] * (B)[1][(1)];
            (C)[(3)][(1)] = (C)[(3)][(1)] + (A)[(3)][2] * (B)[2][(1)];
            (C)[(3)][(1)] = (C)[(3)][(1)] + (A)[(3)][3] * (B)[3][(1)];
          });
          ({
            (C)[(3)][(2)] = (C)[(3)][(2)] + (A)[(3)][0] * (B)[0][(2)];
            (C)[(3)][(2)] = (C)[(3)][(2)] + (A)[(3)][1] * (B)[1][(2)];
            (C)[(3)][(2)] = (C)[(3)][(2)] + (A)[(3)][2] * (B)[2][(2)];
            (C)[(3)][(2)] = (C)[(3)][(2)] + (A)[(3)][3] * (B)[3][(2)];
          });
          ({
            (C)[(3)][(3)] = (C)[(3)][(3)] + (A)[(3)][0] * (B)[0][(3)];
            (C)[(3)][(3)] = (C)[(3)][(3)] + (A)[(3)][1] * (B)[1][(3)];
            (C)[(3)][(3)] = (C)[(3)][(3)] + (A)[(3)][2] * (B)[2][(3)];
            (C)[(3)][(3)] = (C)[(3)][(3)] + (A)[(3)][3] * (B)[3][(3)];
          });
        });
      });
    }
  });
  print_matriu(C);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x140,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
lea    -0xd0(%rbp),%rdi
xor    %esi,%esi
mov    $0x40,%edx
call   1030 <memset@plt>
movl   $0x989680,-0xd4(%rbp)
movl   $0x0,-0xd8(%rbp)
cmpl   $0x4,-0xd8(%rbp)
jae    121e <main+0xde>
movl   $0x0,-0xdc(%rbp)
cmpl   $0x4,-0xdc(%rbp)
jae    1205 <main+0xc5>
mov    $0x0,%al
call   1060 <rand@plt>
mov    %eax,%edx
mov    -0xd8(%rbp),%eax
mov    %eax,%ecx
lea    -0x50(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
mov    -0xdc(%rbp),%ecx
mov    %edx,(%rax,%rcx,4)
mov    $0x0,%al
call   1060 <rand@plt>
mov    %eax,%edx
mov    -0xd8(%rbp),%eax
mov    %eax,%ecx
lea    -0x90(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
mov    -0xdc(%rbp),%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0xdc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xdc(%rbp)
jmp    1197 <main+0x57>
jmp    120a <main+0xca>
mov    -0xd8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd8(%rbp)
jmp    1180 <main+0x40>
cmpl   $0x1,-0x8(%rbp)
jle    123d <main+0xfd>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rdi
mov    $0x0,%al
call   1050 <atoi@plt>
mov    %eax,-0xd4(%rbp)
movl   $0x0,-0xe0(%rbp)
mov    -0xe0(%rbp),%eax
cmp    -0xd4(%rbp),%eax
jae    1879 <main+0x739>
mov    -0xd0(%rbp),%eax
mov    -0x50(%rbp),%ecx
imul   -0x90(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xd0(%rbp)
mov    -0xd0(%rbp),%eax
mov    -0x4c(%rbp),%ecx
imul   -0x80(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xd0(%rbp)
mov    -0xd0(%rbp),%eax
mov    -0x48(%rbp),%ecx
imul   -0x70(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xd0(%rbp)
mov    -0xd0(%rbp),%eax
mov    -0x44(%rbp),%ecx
imul   -0x60(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xd0(%rbp)
mov    %eax,-0xf0(%rbp)
mov    -0xcc(%rbp),%eax
mov    -0x50(%rbp),%ecx
imul   -0x8c(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xcc(%rbp)
mov    -0xcc(%rbp),%eax
mov    -0x4c(%rbp),%ecx
imul   -0x7c(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xcc(%rbp)
mov    -0xcc(%rbp),%eax
mov    -0x48(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xcc(%rbp)
mov    -0xcc(%rbp),%eax
mov    -0x44(%rbp),%ecx
imul   -0x5c(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xcc(%rbp)
mov    %eax,-0xf4(%rbp)
mov    -0xc8(%rbp),%eax
mov    -0x50(%rbp),%ecx
imul   -0x88(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xc8(%rbp)
mov    -0xc8(%rbp),%eax
mov    -0x4c(%rbp),%ecx
imul   -0x78(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xc8(%rbp)
mov    -0xc8(%rbp),%eax
mov    -0x48(%rbp),%ecx
imul   -0x68(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xc8(%rbp)
mov    -0xc8(%rbp),%eax
mov    -0x44(%rbp),%ecx
imul   -0x58(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xc8(%rbp)
mov    %eax,-0xf8(%rbp)
mov    -0xc4(%rbp),%eax
mov    -0x50(%rbp),%ecx
imul   -0x84(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
mov    -0x4c(%rbp),%ecx
imul   -0x74(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
mov    -0x48(%rbp),%ecx
imul   -0x64(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
mov    -0x44(%rbp),%ecx
imul   -0x54(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xc4(%rbp)
mov    %eax,-0x100(%rbp)
mov    -0x100(%rbp),%eax
mov    %eax,-0xfc(%rbp)
mov    -0xc0(%rbp),%eax
mov    -0x40(%rbp),%ecx
imul   -0x90(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xc0(%rbp)
mov    -0xc0(%rbp),%eax
mov    -0x3c(%rbp),%ecx
imul   -0x80(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xc0(%rbp)
mov    -0xc0(%rbp),%eax
mov    -0x38(%rbp),%ecx
imul   -0x70(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xc0(%rbp)
mov    -0xc0(%rbp),%eax
mov    -0x34(%rbp),%ecx
imul   -0x60(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xc0(%rbp)
mov    %eax,-0x104(%rbp)
mov    -0xbc(%rbp),%eax
mov    -0x40(%rbp),%ecx
imul   -0x8c(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xbc(%rbp)
mov    -0xbc(%rbp),%eax
mov    -0x3c(%rbp),%ecx
imul   -0x7c(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xbc(%rbp)
mov    -0xbc(%rbp),%eax
mov    -0x38(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xbc(%rbp)
mov    -0xbc(%rbp),%eax
mov    -0x34(%rbp),%ecx
imul   -0x5c(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xbc(%rbp)
mov    %eax,-0x108(%rbp)
mov    -0xb8(%rbp),%eax
mov    -0x40(%rbp),%ecx
imul   -0x88(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xb8(%rbp)
mov    -0xb8(%rbp),%eax
mov    -0x3c(%rbp),%ecx
imul   -0x78(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xb8(%rbp)
mov    -0xb8(%rbp),%eax
mov    -0x38(%rbp),%ecx
imul   -0x68(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xb8(%rbp)
mov    -0xb8(%rbp),%eax
mov    -0x34(%rbp),%ecx
imul   -0x58(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xb8(%rbp)
mov    %eax,-0x10c(%rbp)
mov    -0xb4(%rbp),%eax
mov    -0x40(%rbp),%ecx
imul   -0x84(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
mov    -0x3c(%rbp),%ecx
imul   -0x74(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
mov    -0x38(%rbp),%ecx
imul   -0x64(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
mov    -0x34(%rbp),%ecx
imul   -0x54(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xb4(%rbp)
mov    %eax,-0x114(%rbp)
mov    -0x114(%rbp),%eax
mov    %eax,-0x110(%rbp)
mov    -0xb0(%rbp),%eax
mov    -0x30(%rbp),%ecx
imul   -0x90(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xb0(%rbp)
mov    -0xb0(%rbp),%eax
mov    -0x2c(%rbp),%ecx
imul   -0x80(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xb0(%rbp)
mov    -0xb0(%rbp),%eax
mov    -0x28(%rbp),%ecx
imul   -0x70(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xb0(%rbp)
mov    -0xb0(%rbp),%eax
mov    -0x24(%rbp),%ecx
imul   -0x60(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xb0(%rbp)
mov    %eax,-0x118(%rbp)
mov    -0xac(%rbp),%eax
mov    -0x30(%rbp),%ecx
imul   -0x8c(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xac(%rbp)
mov    -0xac(%rbp),%eax
mov    -0x2c(%rbp),%ecx
imul   -0x7c(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xac(%rbp)
mov    -0xac(%rbp),%eax
mov    -0x28(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xac(%rbp)
mov    -0xac(%rbp),%eax
mov    -0x24(%rbp),%ecx
imul   -0x5c(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xac(%rbp)
mov    %eax,-0x11c(%rbp)
mov    -0xa8(%rbp),%eax
mov    -0x30(%rbp),%ecx
imul   -0x88(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
mov    -0x2c(%rbp),%ecx
imul   -0x78(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
mov    -0x28(%rbp),%ecx
imul   -0x68(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
mov    -0x24(%rbp),%ecx
imul   -0x58(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xa8(%rbp)
mov    %eax,-0x120(%rbp)
mov    -0xa4(%rbp),%eax
mov    -0x30(%rbp),%ecx
imul   -0x84(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
mov    -0x2c(%rbp),%ecx
imul   -0x74(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
mov    -0x28(%rbp),%ecx
imul   -0x64(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
mov    -0x24(%rbp),%ecx
imul   -0x54(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xa4(%rbp)
mov    %eax,-0x128(%rbp)
mov    -0x128(%rbp),%eax
mov    %eax,-0x124(%rbp)
mov    -0xa0(%rbp),%eax
mov    -0x20(%rbp),%ecx
imul   -0x90(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xa0(%rbp)
mov    -0xa0(%rbp),%eax
mov    -0x1c(%rbp),%ecx
imul   -0x80(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xa0(%rbp)
mov    -0xa0(%rbp),%eax
mov    -0x18(%rbp),%ecx
imul   -0x70(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xa0(%rbp)
mov    -0xa0(%rbp),%eax
mov    -0x14(%rbp),%ecx
imul   -0x60(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xa0(%rbp)
mov    %eax,-0x130(%rbp)
mov    -0x9c(%rbp),%eax
mov    -0x20(%rbp),%ecx
imul   -0x8c(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
mov    -0x1c(%rbp),%ecx
imul   -0x7c(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
mov    -0x18(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
mov    -0x14(%rbp),%ecx
imul   -0x5c(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x9c(%rbp)
mov    %eax,-0x134(%rbp)
mov    -0x98(%rbp),%eax
mov    -0x20(%rbp),%ecx
imul   -0x88(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x98(%rbp)
mov    -0x98(%rbp),%eax
mov    -0x1c(%rbp),%ecx
imul   -0x78(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x98(%rbp)
mov    -0x98(%rbp),%eax
mov    -0x18(%rbp),%ecx
imul   -0x68(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x98(%rbp)
mov    -0x98(%rbp),%eax
mov    -0x14(%rbp),%ecx
imul   -0x58(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x98(%rbp)
mov    %eax,-0x138(%rbp)
mov    -0x94(%rbp),%eax
mov    -0x20(%rbp),%ecx
imul   -0x84(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x94(%rbp)
mov    -0x94(%rbp),%eax
mov    -0x1c(%rbp),%ecx
imul   -0x74(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x94(%rbp)
mov    -0x94(%rbp),%eax
mov    -0x18(%rbp),%ecx
imul   -0x64(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x94(%rbp)
mov    -0x94(%rbp),%eax
mov    -0x14(%rbp),%ecx
imul   -0x54(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x94(%rbp)
mov    %eax,-0x140(%rbp)
mov    -0x140(%rbp),%eax
mov    %eax,-0x13c(%rbp)
mov    -0x13c(%rbp),%eax
mov    %eax,-0x12c(%rbp)
mov    -0xe0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe0(%rbp)
jmp    1247 <main+0x107>
lea    -0xd0(%rbp),%rdi
mov    $0x0,%al
call   1040 <print_matriu@plt>
xor    %eax,%eax
add    $0x140,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x188,%rsp
mov    %rsi,0x50(%rsp)
mov    %edi,0x8(%rsp)
xorps  %xmm0,%xmm0
movaps %xmm0,0xe0(%rsp)
movaps %xmm0,0xd0(%rsp)
movaps %xmm0,0xc0(%rsp)
movaps %xmm0,0xb0(%rsp)
xor    %eax,%eax
call   1050 <rand@plt>
mov    %eax,0x18(%rsp)
xor    %eax,%eax
call   1050 <rand@plt>
mov    %eax,%r15d
xor    %eax,%eax
call   1050 <rand@plt>
mov    %eax,%ebp
xor    %eax,%eax
call   1050 <rand@plt>
mov    %eax,%r12d
xor    %eax,%eax
call   1050 <rand@plt>
mov    %eax,0x14(%rsp)
xor    %eax,%eax
call   1050 <rand@plt>
mov    %eax,%r14d
xor    %eax,%eax
call   1050 <rand@plt>
mov    %eax,0x6c(%rsp)
xor    %eax,%eax
call   1050 <rand@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   1050 <rand@plt>
mov    %eax,%r13d
xor    %eax,%eax
call   1050 <rand@plt>
mov    %eax,0xc(%rsp)
xor    %eax,%eax
call   1050 <rand@plt>
mov    %rax,0xa0(%rsp)
xor    %eax,%eax
call   1050 <rand@plt>
mov    %rax,0x88(%rsp)
xor    %eax,%eax
call   1050 <rand@plt>
mov    %eax,0x10(%rsp)
xor    %eax,%eax
call   1050 <rand@plt>
mov    %rax,0x98(%rsp)
xor    %eax,%eax
call   1050 <rand@plt>
mov    %eax,0x4c(%rsp)
xor    %eax,%eax
call   1050 <rand@plt>
mov    %eax,0x34(%rsp)
xor    %eax,%eax
call   1050 <rand@plt>
mov    %rax,0x78(%rsp)
xor    %eax,%eax
call   1050 <rand@plt>
mov    %eax,0x4(%rsp)
xor    %eax,%eax
call   1050 <rand@plt>
mov    %rax,0x80(%rsp)
xor    %eax,%eax
call   1050 <rand@plt>
mov    %eax,(%rsp)
xor    %eax,%eax
call   1050 <rand@plt>
mov    %eax,0x68(%rsp)
xor    %eax,%eax
call   1050 <rand@plt>
mov    %eax,0x1c(%rsp)
xor    %eax,%eax
call   1050 <rand@plt>
mov    %eax,0x48(%rsp)
xor    %eax,%eax
call   1050 <rand@plt>
mov    %eax,0x30(%rsp)
xor    %eax,%eax
call   1050 <rand@plt>
mov    %rax,0x70(%rsp)
xor    %eax,%eax
call   1050 <rand@plt>
mov    %eax,0x44(%rsp)
xor    %eax,%eax
call   1050 <rand@plt>
mov    %rax,0x90(%rsp)
xor    %eax,%eax
call   1050 <rand@plt>
mov    %eax,0x40(%rsp)
xor    %eax,%eax
call   1050 <rand@plt>
mov    %eax,0x64(%rsp)
xor    %eax,%eax
call   1050 <rand@plt>
mov    %eax,0x3c(%rsp)
xor    %eax,%eax
call   1050 <rand@plt>
mov    %eax,0x38(%rsp)
xor    %eax,%eax
call   1050 <rand@plt>
mov    %eax,0x60(%rsp)
mov    $0x989680,%eax
cmpl   $0x2,0x8(%rsp)
jl     12fe <main+0x1ce>
mov    0x50(%rsp),%rax
mov    0x8(%rax),%rdi
xor    %eax,%eax
call   1040 <atoi@plt>
test   %eax,%eax
je     1b2b <main+0x9fb>
mov    %r15d,%edx
mov    0x18(%rsp),%ecx
imul   %ecx,%edx
mov    %edx,0x14c(%rsp)
mov    %r12d,%edx
imul   %ecx,%edx
mov    %edx,0x5c(%rsp)
mov    %r14d,%edx
imul   %ecx,%edx
mov    %edx,0x58(%rsp)
imul   %ebx,%ecx
mov    %ecx,0x18(%rsp)
mov    %r13d,%ecx
imul   %r15d,%ecx
mov    %ecx,0xf8(%rsp)
mov    %r13d,%ecx
imul   %r12d,%ecx
mov    %rcx,0x180(%rsp)
mov    %r13d,%ecx
imul   %r14d,%ecx
mov    %rcx,0x178(%rsp)
imul   %ebx,%r13d
mov    %r13,0x170(%rsp)
mov    0x78(%rsp),%rcx
mov    %ecx,%edx
imul   %r15d,%edx
mov    %edx,0x148(%rsp)
mov    %ecx,%edx
imul   %r12d,%edx
mov    %rdx,0x168(%rsp)
mov    %ecx,%edx
imul   %r14d,%edx
mov    %rdx,0x160(%rsp)
imul   %ebx,%ecx
mov    %rcx,0x78(%rsp)
mov    0x70(%rsp),%rcx
imul   %ecx,%r15d
mov    %r15d,0x144(%rsp)
imul   %ecx,%r12d
mov    %r12,0x158(%rsp)
imul   %ecx,%r14d
mov    %r14,0x150(%rsp)
imul   %ebx,%ecx
mov    %rcx,0x70(%rsp)
mov    0xc(%rsp),%ebx
mov    0x6c(%rsp),%edx
mov    %ebx,%esi
mov    %ebp,%ecx
imul   %ebp,%esi
mov    %esi,0x50(%rsp)
mov    0x80(%rsp),%rbp
mov    %eax,%r12d
mov    0x88(%rsp),%rax
mov    %eax,%esi
imul   %ecx,%esi
mov    %esi,0x8(%rsp)
mov    0x98(%rsp),%rdi
mov    %edi,%esi
imul   %ecx,%esi
mov    %esi,0x2c(%rsp)
mov    0x34(%rsp),%r8d
imul   %r8d,%ecx
mov    %ecx,0x24(%rsp)
mov    0xa0(%rsp),%rcx
mov    %ecx,%esi
imul   %ebx,%esi
mov    %esi,0x20(%rsp)
mov    %ecx,%esi
imul   %eax,%esi
mov    %rsi,0x100(%rsp)
mov    %ecx,%r13d
imul   %edi,%r13d
imul   %r8d,%ecx
mov    %rcx,0xa0(%rsp)
mov    %ebp,%esi
imul   %ebx,%esi
mov    %esi,0x28(%rsp)
mov    %ebp,%esi
imul   %eax,%esi
mov    %rsi,0x108(%rsp)
mov    %ebp,%esi
imul   %edi,%esi
mov    %rsi,0x110(%rsp)
imul   %r8d,%ebp
mov    %rbp,0x80(%rsp)
mov    0x90(%rsp),%rsi
imul   %esi,%ebx
mov    %ebx,0xc(%rsp)
imul   %esi,%eax
mov    %rax,0x88(%rsp)
imul   %esi,%edi
mov    %rdi,0x98(%rsp)
imul   %r8d,%esi
mov    %rsi,0x90(%rsp)
mov    0x4(%rsp),%ecx
mov    %ecx,%r10d
mov    0x14(%rsp),%r9d
imul   %r9d,%r10d
mov    (%rsp),%edi
mov    %edi,%ebx
imul   %r9d,%ebx
mov    0x1c(%rsp),%esi
mov    %esi,%r14d
imul   %r9d,%r14d
mov    0x30(%rsp),%r8d
imul   %r8d,%r9d
mov    0x10(%rsp),%r11d
mov    %r11d,%r15d
imul   %ecx,%r15d
mov    %r11d,%eax
imul   %edi,%eax
mov    %eax,0x11c(%rsp)
mov    %r11d,%eax
imul   %esi,%eax
mov    %eax,0x120(%rsp)
imul   %r8d,%r11d
mov    0x68(%rsp),%ebp
mov    %ebp,%eax
imul   %ecx,%eax
mov    %eax,0x124(%rsp)
mov    %ebp,%eax
imul   %edi,%eax
mov    %eax,0x128(%rsp)
mov    %ebp,%eax
imul   %esi,%eax
mov    %eax,0x12c(%rsp)
imul   %r8d,%ebp
mov    %ebp,0x68(%rsp)
mov    0x64(%rsp),%eax
imul   %eax,%ecx
mov    %ecx,0x4(%rsp)
imul   %eax,%edi
mov    %edi,(%rsp)
imul   %eax,%esi
mov    %esi,0x1c(%rsp)
imul   %r8d,%eax
mov    %eax,0x64(%rsp)
mov    0x44(%rsp),%r8d
mov    %r8d,%eax
imul   %edx,%eax
mov    %eax,0x13c(%rsp)
mov    0x40(%rsp),%esi
mov    %esi,%ecx
imul   %edx,%ecx
mov    %ecx,0x138(%rsp)
mov    0x3c(%rsp),%ecx
mov    %ecx,%eax
imul   %edx,%eax
mov    %eax,0x134(%rsp)
mov    0x60(%rsp),%edi
imul   %edi,%edx
mov    %edx,0x6c(%rsp)
mov    0x4c(%rsp),%eax
mov    %eax,%edx
imul   %r8d,%edx
mov    %edx,0x130(%rsp)
mov    %eax,%edx
imul   %esi,%edx
mov    %edx,0xac(%rsp)
mov    %eax,%edx
imul   %ecx,%edx
mov    %edx,0xa8(%rsp)
imul   %edi,%eax
mov    %eax,0x4c(%rsp)
mov    0x48(%rsp),%eax
mov    %eax,%edx
imul   %r8d,%edx
mov    %edx,0x140(%rsp)
mov    %eax,%edx
imul   %esi,%edx
mov    %edx,0x30(%rsp)
mov    %eax,%edx
imul   %ecx,%edx
mov    %edx,0x34(%rsp)
imul   %edi,%eax
mov    %eax,0x48(%rsp)
mov    0x38(%rsp),%eax
imul   %eax,%r8d
mov    %r8d,0x44(%rsp)
imul   %eax,%esi
mov    %esi,0x40(%rsp)
imul   %eax,%ecx
mov    %ecx,0x3c(%rsp)
imul   %edi,%eax
mov    %eax,0x38(%rsp)
mov    0xb0(%rsp),%eax
mov    0x14c(%rsp),%ecx
add    %ecx,%eax
mov    0x50(%rsp),%edx
add    %edx,%eax
add    %ecx,%edx
add    %r10d,%eax
mov    %eax,0x14(%rsp)
add    %r10d,%edx
mov    %edx,0x50(%rsp)
mov    0xb4(%rsp),%edx
mov    0x5c(%rsp),%ecx
add    %ecx,%edx
mov    0x8(%rsp),%eax
add    %eax,%edx
add    %ecx,%eax
add    %ebx,%edx
mov    %edx,0x10(%rsp)
add    %ebx,%eax
mov    %eax,0x8(%rsp)
mov    0xb8(%rsp),%edx
mov    0x58(%rsp),%ecx
add    %ecx,%edx
mov    0x2c(%rsp),%eax
add    %eax,%edx
add    %ecx,%eax
add    %r14d,%edx
mov    %edx,0x60(%rsp)
add    %r14d,%eax
mov    %eax,0x2c(%rsp)
mov    0xbc(%rsp),%eax
mov    0x18(%rsp),%ecx
add    %ecx,%eax
mov    0x24(%rsp),%edx
add    %edx,%eax
add    %ecx,%edx
add    %r9d,%eax
mov    %eax,0x5c(%rsp)
add    %r9d,%edx
mov    %edx,0x24(%rsp)
mov    0xc0(%rsp),%edx
mov    0xf8(%rsp),%ecx
add    %ecx,%edx
mov    0x20(%rsp),%eax
add    %eax,%edx
add    %ecx,%eax
add    %r15d,%edx
mov    %edx,0x18(%rsp)
add    %r15d,%eax
mov    %eax,0x20(%rsp)
mov    0x100(%rsp),%rcx
mov    0x180(%rsp),%rdx
lea    (%rcx,%rdx,1),%edi
add    0xc4(%rsp),%ecx
add    %edx,%ecx
mov    0x11c(%rsp),%edx
add    %edx,%edi
add    %edx,%ecx
mov    %rcx,0x100(%rsp)
mov    %r13,%rcx
mov    0x178(%rsp),%rdx
lea    (%rdx,%r13,1),%eax
add    0xc8(%rsp),%ecx
add    %edx,%ecx
mov    0x120(%rsp),%edx
add    %edx,%eax
mov    %eax,%r10d
add    %edx,%ecx
mov    %rcx,0xf8(%rsp)
mov    0x170(%rsp),%rcx
mov    0xa0(%rsp),%r15
lea    (%r15,%rcx,1),%r13d
add    0xcc(%rsp),%r15d
add    %ecx,%r15d
add    %r11d,%r13d
add    %r11d,%r15d
mov    %r15,0xa0(%rsp)
mov    0xd0(%rsp),%edx
mov    0x148(%rsp),%eax
add    %eax,%edx
mov    0x28(%rsp),%ecx
add    %ecx,%edx
add    %eax,%ecx
mov    0x124(%rsp),%eax
add    %eax,%edx
mov    %edx,0x58(%rsp)
add    %eax,%ecx
mov    %ecx,0x28(%rsp)
mov    0x108(%rsp),%rcx
mov    0x168(%rsp),%rax
lea    (%rcx,%rax,1),%ebp
add    0xd4(%rsp),%ecx
add    %eax,%ecx
mov    0x128(%rsp),%eax
add    %eax,%ebp
add    %eax,%ecx
mov    %rcx,0x108(%rsp)
mov    0x110(%rsp),%rcx
mov    0x160(%rsp),%rax
lea    (%rcx,%rax,1),%edx
add    0xd8(%rsp),%ecx
add    %eax,%ecx
mov    0x12c(%rsp),%eax
add    %eax,%edx
mov    %edx,%ebx
add    %eax,%ecx
mov    %rcx,0x110(%rsp)
mov    0x78(%rsp),%rcx
mov    0x80(%rsp),%rax
lea    (%rax,%rcx,1),%r8d
add    0xdc(%rsp),%eax
add    %ecx,%eax
mov    0x68(%rsp),%ecx
add    %ecx,%r8d
add    %ecx,%eax
mov    %rax,0x80(%rsp)
mov    0xe0(%rsp),%r9d
mov    0x144(%rsp),%eax
add    %eax,%r9d
mov    0xc(%rsp),%ecx
add    %ecx,%r9d
add    %eax,%ecx
mov    0x4(%rsp),%eax
add    %eax,%r9d
add    %eax,%ecx
mov    %ecx,0xc(%rsp)
mov    0x158(%rsp),%rax
mov    0x88(%rsp),%rcx
lea    (%rcx,%rax,1),%r15d
add    0xe4(%rsp),%ecx
add    %eax,%ecx
mov    (%rsp),%eax
add    %eax,%r15d
add    %eax,%ecx
mov    %rcx,0x88(%rsp)
mov    0x150(%rsp),%rax
mov    0x98(%rsp),%rcx
lea    (%rcx,%rax,1),%r11d
add    0xe8(%rsp),%ecx
add    %eax,%ecx
mov    0x1c(%rsp),%eax
add    %eax,%r11d
add    %eax,%ecx
mov    %rcx,0x98(%rsp)
mov    0x70(%rsp),%r14
mov    0x90(%rsp),%rcx
lea    (%rcx,%r14,1),%esi
add    0xec(%rsp),%ecx
add    %r14d,%ecx
mov    0x64(%rsp),%eax
add    %eax,%esi
add    %eax,%ecx
mov    %rcx,0x90(%rsp)
add    0xac(%rsp),%edi
mov    %r10d,%edx
add    0xa8(%rsp),%edx
mov    %r13d,%eax
add    0x4c(%rsp),%eax
add    0x30(%rsp),%ebp
mov    %ebp,(%rsp)
mov    %ebx,%ecx
add    0x34(%rsp),%ecx
add    0x48(%rsp),%r8d
mov    %r8d,0x4(%rsp)
add    0x40(%rsp),%r15d
add    0x3c(%rsp),%r11d
add    0x38(%rsp),%esi
mov    0x13c(%rsp),%r10d
mov    0x50(%rsp),%ebp
add    %r10d,%ebp
add    $0xffffffff,%r12d
imul   %r12d,%ebp
mov    %ebp,0x50(%rsp)
mov    0x138(%rsp),%r8d
mov    0x8(%rsp),%ebx
add    %r8d,%ebx
imul   %r12d,%ebx
mov    %ebx,0x8(%rsp)
mov    0x134(%rsp),%r14d
mov    0x2c(%rsp),%ebx
add    %r14d,%ebx
imul   %r12d,%ebx
mov    %ebx,0x2c(%rsp)
mov    0x6c(%rsp),%r13d
mov    0x24(%rsp),%ebx
add    %r13d,%ebx
imul   %r12d,%ebx
mov    %ebx,0x24(%rsp)
mov    0x130(%rsp),%ebx
mov    0x20(%rsp),%ebp
add    %ebx,%ebp
imul   %r12d,%ebp
mov    %ebp,0x20(%rsp)
imul   %r12d,%edi
imul   %r12d,%edx
mov    %edx,0x70(%rsp)
imul   %r12d,%eax
mov    %eax,0x78(%rsp)
mov    0x140(%rsp),%edx
mov    0x28(%rsp),%eax
add    %edx,%eax
imul   %r12d,%eax
mov    %eax,0x28(%rsp)
mov    (%rsp),%eax
imul   %r12d,%eax
mov    %eax,(%rsp)
imul   %r12d,%ecx
mov    %ecx,0x1c(%rsp)
mov    0x4(%rsp),%eax
imul   %r12d,%eax
mov    %eax,0x4(%rsp)
mov    0xc(%rsp),%eax
add    0x44(%rsp),%eax
imul   %r12d,%eax
mov    %eax,0xc(%rsp)
imul   %r12d,%r15d
imul   %r12d,%r11d
imul   %esi,%r12d
mov    0x14(%rsp),%eax
add    %r10d,%eax
add    0x50(%rsp),%eax
mov    %eax,0x14(%rsp)
mov    0x10(%rsp),%eax
add    %r8d,%eax
add    0x8(%rsp),%eax
mov    %eax,0x10(%rsp)
mov    0x60(%rsp),%eax
add    %r14d,%eax
add    0x2c(%rsp),%eax
mov    0x5c(%rsp),%esi
add    %r13d,%esi
add    0x24(%rsp),%esi
mov    0x18(%rsp),%ebp
add    %ebx,%ebp
add    0x20(%rsp),%ebp
mov    %ebp,%r8d
mov    0x100(%rsp),%rbx
add    0xac(%rsp),%ebx
add    %edi,%ebx
mov    0xf8(%rsp),%rbp
add    0xa8(%rsp),%ebp
add    0x70(%rsp),%ebp
mov    0xa0(%rsp),%rdi
add    0x4c(%rsp),%edi
add    0x78(%rsp),%edi
mov    %rdi,%r10
mov    0x58(%rsp),%ecx
add    %edx,%ecx
add    0x28(%rsp),%ecx
mov    %ecx,%r13d
mov    0x108(%rsp),%rdi
add    0x30(%rsp),%edi
add    (%rsp),%edi
mov    0x110(%rsp),%rdx
add    0x34(%rsp),%edx
add    0x1c(%rsp),%edx
mov    0x80(%rsp),%rcx
add    0x48(%rsp),%ecx
add    0x4(%rsp),%ecx
add    0x44(%rsp),%r9d
add    0xc(%rsp),%r9d
mov    0x88(%rsp),%r14
add    0x40(%rsp),%r14d
add    %r15d,%r14d
mov    0x98(%rsp),%r15
add    0x3c(%rsp),%r15d
add    %r11d,%r15d
mov    0x90(%rsp),%r11
add    0x38(%rsp),%r11d
add    %r12d,%r11d
mov    0x14(%rsp),%r12d
mov    %r12d,0xb0(%rsp)
mov    0x10(%rsp),%r12d
mov    %r12d,0xb4(%rsp)
mov    %eax,0xb8(%rsp)
mov    %esi,0xbc(%rsp)
mov    %r8d,0xc0(%rsp)
mov    %ebx,0xc4(%rsp)
mov    %ebp,0xc8(%rsp)
mov    %r10d,0xcc(%rsp)
mov    %r13d,0xd0(%rsp)
mov    %edi,0xd4(%rsp)
mov    %edx,0xd8(%rsp)
mov    %ecx,0xdc(%rsp)
mov    %r9d,0xe0(%rsp)
mov    %r14d,0xe4(%rsp)
mov    %r15d,0xe8(%rsp)
mov    %r11d,0xec(%rsp)
lea    0xb0(%rsp),%rdi
xor    %eax,%eax
call   1030 <print_matriu@plt>
xor    %eax,%eax
add    $0x188,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8**
%6 = alloca [4 x [4 x i32]]
%7 = alloca [4 x [4 x i32]]
%8 = alloca [4 x [4 x i32]]
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
%25 = alloca i32
%26 = alloca i32
%27 = alloca i32
%28 = alloca i32
%29 = alloca i32
%30 = alloca i32
%31 = alloca i32
%32 = alloca i32
%33 = alloca i32
%34 = alloca i32
%35 = alloca i32
%36 = alloca i32
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
%37 = bitcast [4 x [4 x i32]]* %8 to i8*
store i32 10000000, i32* %9
store i32 0, i32* %10
br label %38
38: ; preds = %64, %2
%39 = load i32, i32* %10
%40 = icmp ult i32 %39, 4
br i1 %40, label %41, label %67
41: ; preds = %38
store i32 0, i32* %11
br label %42
42: ; preds = %60, %41
%43 = load i32, i32* %11
%44 = icmp ult i32 %43, 4
br i1 %44, label %45, label %63
45: ; preds = %42
%46 = call i32 (...) @rand()
%47 = load i32, i32* %10
%48 = zext i32 %47 to i64
%49 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 %48
%50 = load i32, i32* %11
%51 = zext i32 %50 to i64
%52 = getelementptr inbounds [4 x i32], [4 x i32]* %49, i64 0, i64 %51
store i32 %46, i32* %52
%53 = call i32 (...) @rand()
%54 = load i32, i32* %10
%55 = zext i32 %54 to i64
%56 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 %55
%57 = load i32, i32* %11
%58 = zext i32 %57 to i64
%59 = getelementptr inbounds [4 x i32], [4 x i32]* %56, i64 0, i64 %58
store i32 %53, i32* %59
br label %60
60: ; preds = %45
%61 = load i32, i32* %11
%62 = add i32 %61, 1
store i32 %62, i32* %11
br label %42
63: ; preds = %42
br label %64
64: ; preds = %63
%65 = load i32, i32* %10
%66 = add i32 %65, 1
store i32 %66, i32* %10
br label %38
67: ; preds = %38
%68 = load i32, i32* %4
%69 = icmp sgt i32 %68, 1
br i1 %69, label %70, label %75
70: ; preds = %67
%71 = load i8**, i8*** %5
%72 = getelementptr inbounds i8*, i8** %71, i64 1
%73 = load i8*, i8** %72
%74 = call i32 (i8*, ...) bitcast (i32 (...)* @atoi to i32 (i8*, ...)*)(i8* %73)
store i32 %74, i32* %9
br label %75
75: ; preds = %70, %67
store i32 0, i32* %12
br label %76
76: ; preds = %934, %75
%77 = load i32, i32* %12
%78 = load i32, i32* %9
%79 = icmp ult i32 %77, %78
br i1 %79, label %80, label %937
80: ; preds = %76
%81 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 0
%82 = getelementptr inbounds [4 x i32], [4 x i32]* %81, i64 0, i64 0
%83 = load i32, i32* %82
%84 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 0
%85 = getelementptr inbounds [4 x i32], [4 x i32]* %84, i64 0, i64 0
%86 = load i32, i32* %85
%87 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 0
%88 = getelementptr inbounds [4 x i32], [4 x i32]* %87, i64 0, i64 0
%89 = load i32, i32* %88
%90 = mul nsw i32 %86, %89
%91 = add nsw i32 %83, %90
%92 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 0
%93 = getelementptr inbounds [4 x i32], [4 x i32]* %92, i64 0, i64 0
store i32 %91, i32* %93
%94 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 0
%95 = getelementptr inbounds [4 x i32], [4 x i32]* %94, i64 0, i64 0
%96 = load i32, i32* %95
%97 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 0
%98 = getelementptr inbounds [4 x i32], [4 x i32]* %97, i64 0, i64 1
%99 = load i32, i32* %98
%100 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 1
%101 = getelementptr inbounds [4 x i32], [4 x i32]* %100, i64 0, i64 0
%102 = load i32, i32* %101
%103 = mul nsw i32 %99, %102
%104 = add nsw i32 %96, %103
%105 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 0
%106 = getelementptr inbounds [4 x i32], [4 x i32]* %105, i64 0, i64 0
store i32 %104, i32* %106
%107 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 0
%108 = getelementptr inbounds [4 x i32], [4 x i32]* %107, i64 0, i64 0
%109 = load i32, i32* %108
%110 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 0
%111 = getelementptr inbounds [4 x i32], [4 x i32]* %110, i64 0, i64 2
%112 = load i32, i32* %111
%113 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 2
%114 = getelementptr inbounds [4 x i32], [4 x i32]* %113, i64 0, i64 0
%115 = load i32, i32* %114
%116 = mul nsw i32 %112, %115
%117 = add nsw i32 %109, %116
%118 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 0
%119 = getelementptr inbounds [4 x i32], [4 x i32]* %118, i64 0, i64 0
store i32 %117, i32* %119
%120 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 0
%121 = getelementptr inbounds [4 x i32], [4 x i32]* %120, i64 0, i64 0
%122 = load i32, i32* %121
%123 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 0
%124 = getelementptr inbounds [4 x i32], [4 x i32]* %123, i64 0, i64 3
%125 = load i32, i32* %124
%126 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 3
%127 = getelementptr inbounds [4 x i32], [4 x i32]* %126, i64 0, i64 0
%128 = load i32, i32* %127
%129 = mul nsw i32 %125, %128
%130 = add nsw i32 %122, %129
%131 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 0
%132 = getelementptr inbounds [4 x i32], [4 x i32]* %131, i64 0, i64 0
store i32 %130, i32* %132
store i32 %130, i32* %16
%133 = load i32, i32* %16
%134 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 0
%135 = getelementptr inbounds [4 x i32], [4 x i32]* %134, i64 0, i64 1
%136 = load i32, i32* %135
%137 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 0
%138 = getelementptr inbounds [4 x i32], [4 x i32]* %137, i64 0, i64 0
%139 = load i32, i32* %138
%140 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 0
%141 = getelementptr inbounds [4 x i32], [4 x i32]* %140, i64 0, i64 1
%142 = load i32, i32* %141
%143 = mul nsw i32 %139, %142
%144 = add nsw i32 %136, %143
%145 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 0
%146 = getelementptr inbounds [4 x i32], [4 x i32]* %145, i64 0, i64 1
store i32 %144, i32* %146
%147 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 0
%148 = getelementptr inbounds [4 x i32], [4 x i32]* %147, i64 0, i64 1
%149 = load i32, i32* %148
%150 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 0
%151 = getelementptr inbounds [4 x i32], [4 x i32]* %150, i64 0, i64 1
%152 = load i32, i32* %151
%153 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 1
%154 = getelementptr inbounds [4 x i32], [4 x i32]* %153, i64 0, i64 1
%155 = load i32, i32* %154
%156 = mul nsw i32 %152, %155
%157 = add nsw i32 %149, %156
%158 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 0
%159 = getelementptr inbounds [4 x i32], [4 x i32]* %158, i64 0, i64 1
store i32 %157, i32* %159
%160 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 0
%161 = getelementptr inbounds [4 x i32], [4 x i32]* %160, i64 0, i64 1
%162 = load i32, i32* %161
%163 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 0
%164 = getelementptr inbounds [4 x i32], [4 x i32]* %163, i64 0, i64 2
%165 = load i32, i32* %164
%166 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 2
%167 = getelementptr inbounds [4 x i32], [4 x i32]* %166, i64 0, i64 1
%168 = load i32, i32* %167
%169 = mul nsw i32 %165, %168
%170 = add nsw i32 %162, %169
%171 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 0
%172 = getelementptr inbounds [4 x i32], [4 x i32]* %171, i64 0, i64 1
store i32 %170, i32* %172
%173 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 0
%174 = getelementptr inbounds [4 x i32], [4 x i32]* %173, i64 0, i64 1
%175 = load i32, i32* %174
%176 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 0
%177 = getelementptr inbounds [4 x i32], [4 x i32]* %176, i64 0, i64 3
%178 = load i32, i32* %177
%179 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 3
%180 = getelementptr inbounds [4 x i32], [4 x i32]* %179, i64 0, i64 1
%181 = load i32, i32* %180
%182 = mul nsw i32 %178, %181
%183 = add nsw i32 %175, %182
%184 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 0
%185 = getelementptr inbounds [4 x i32], [4 x i32]* %184, i64 0, i64 1
store i32 %183, i32* %185
store i32 %183, i32* %17
%186 = load i32, i32* %17
%187 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 0
%188 = getelementptr inbounds [4 x i32], [4 x i32]* %187, i64 0, i64 2
%189 = load i32, i32* %188
%190 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 0
%191 = getelementptr inbounds [4 x i32], [4 x i32]* %190, i64 0, i64 0
%192 = load i32, i32* %191
%193 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 0
%194 = getelementptr inbounds [4 x i32], [4 x i32]* %193, i64 0, i64 2
%195 = load i32, i32* %194
%196 = mul nsw i32 %192, %195
%197 = add nsw i32 %189, %196
%198 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 0
%199 = getelementptr inbounds [4 x i32], [4 x i32]* %198, i64 0, i64 2
store i32 %197, i32* %199
%200 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 0
%201 = getelementptr inbounds [4 x i32], [4 x i32]* %200, i64 0, i64 2
%202 = load i32, i32* %201
%203 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 0
%204 = getelementptr inbounds [4 x i32], [4 x i32]* %203, i64 0, i64 1
%205 = load i32, i32* %204
%206 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 1
%207 = getelementptr inbounds [4 x i32], [4 x i32]* %206, i64 0, i64 2
%208 = load i32, i32* %207
%209 = mul nsw i32 %205, %208
%210 = add nsw i32 %202, %209
%211 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 0
%212 = getelementptr inbounds [4 x i32], [4 x i32]* %211, i64 0, i64 2
store i32 %210, i32* %212
%213 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 0
%214 = getelementptr inbounds [4 x i32], [4 x i32]* %213, i64 0, i64 2
%215 = load i32, i32* %214
%216 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 0
%217 = getelementptr inbounds [4 x i32], [4 x i32]* %216, i64 0, i64 2
%218 = load i32, i32* %217
%219 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 2
%220 = getelementptr inbounds [4 x i32], [4 x i32]* %219, i64 0, i64 2
%221 = load i32, i32* %220
%222 = mul nsw i32 %218, %221
%223 = add nsw i32 %215, %222
%224 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 0
%225 = getelementptr inbounds [4 x i32], [4 x i32]* %224, i64 0, i64 2
store i32 %223, i32* %225
%226 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 0
%227 = getelementptr inbounds [4 x i32], [4 x i32]* %226, i64 0, i64 2
%228 = load i32, i32* %227
%229 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 0
%230 = getelementptr inbounds [4 x i32], [4 x i32]* %229, i64 0, i64 3
%231 = load i32, i32* %230
%232 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 3
%233 = getelementptr inbounds [4 x i32], [4 x i32]* %232, i64 0, i64 2
%234 = load i32, i32* %233
%235 = mul nsw i32 %231, %234
%236 = add nsw i32 %228, %235
%237 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 0
%238 = getelementptr inbounds [4 x i32], [4 x i32]* %237, i64 0, i64 2
store i32 %236, i32* %238
store i32 %236, i32* %18
%239 = load i32, i32* %18
%240 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 0
%241 = getelementptr inbounds [4 x i32], [4 x i32]* %240, i64 0, i64 3
%242 = load i32, i32* %241
%243 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 0
%244 = getelementptr inbounds [4 x i32], [4 x i32]* %243, i64 0, i64 0
%245 = load i32, i32* %244
%246 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 0
%247 = getelementptr inbounds [4 x i32], [4 x i32]* %246, i64 0, i64 3
%248 = load i32, i32* %247
%249 = mul nsw i32 %245, %248
%250 = add nsw i32 %242, %249
%251 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 0
%252 = getelementptr inbounds [4 x i32], [4 x i32]* %251, i64 0, i64 3
store i32 %250, i32* %252
%253 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 0
%254 = getelementptr inbounds [4 x i32], [4 x i32]* %253, i64 0, i64 3
%255 = load i32, i32* %254
%256 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 0
%257 = getelementptr inbounds [4 x i32], [4 x i32]* %256, i64 0, i64 1
%258 = load i32, i32* %257
%259 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 1
%260 = getelementptr inbounds [4 x i32], [4 x i32]* %259, i64 0, i64 3
%261 = load i32, i32* %260
%262 = mul nsw i32 %258, %261
%263 = add nsw i32 %255, %262
%264 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 0
%265 = getelementptr inbounds [4 x i32], [4 x i32]* %264, i64 0, i64 3
store i32 %263, i32* %265
%266 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 0
%267 = getelementptr inbounds [4 x i32], [4 x i32]* %266, i64 0, i64 3
%268 = load i32, i32* %267
%269 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 0
%270 = getelementptr inbounds [4 x i32], [4 x i32]* %269, i64 0, i64 2
%271 = load i32, i32* %270
%272 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 2
%273 = getelementptr inbounds [4 x i32], [4 x i32]* %272, i64 0, i64 3
%274 = load i32, i32* %273
%275 = mul nsw i32 %271, %274
%276 = add nsw i32 %268, %275
%277 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 0
%278 = getelementptr inbounds [4 x i32], [4 x i32]* %277, i64 0, i64 3
store i32 %276, i32* %278
%279 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 0
%280 = getelementptr inbounds [4 x i32], [4 x i32]* %279, i64 0, i64 3
%281 = load i32, i32* %280
%282 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 0
%283 = getelementptr inbounds [4 x i32], [4 x i32]* %282, i64 0, i64 3
%284 = load i32, i32* %283
%285 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 3
%286 = getelementptr inbounds [4 x i32], [4 x i32]* %285, i64 0, i64 3
%287 = load i32, i32* %286
%288 = mul nsw i32 %284, %287
%289 = add nsw i32 %281, %288
%290 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 0
%291 = getelementptr inbounds [4 x i32], [4 x i32]* %290, i64 0, i64 3
store i32 %289, i32* %291
store i32 %289, i32* %20
%292 = load i32, i32* %20
store i32 %292, i32* %19
%293 = load i32, i32* %19
%294 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 1
%295 = getelementptr inbounds [4 x i32], [4 x i32]* %294, i64 0, i64 0
%296 = load i32, i32* %295
%297 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 1
%298 = getelementptr inbounds [4 x i32], [4 x i32]* %297, i64 0, i64 0
%299 = load i32, i32* %298
%300 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 0
%301 = getelementptr inbounds [4 x i32], [4 x i32]* %300, i64 0, i64 0
%302 = load i32, i32* %301
%303 = mul nsw i32 %299, %302
%304 = add nsw i32 %296, %303
%305 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 1
%306 = getelementptr inbounds [4 x i32], [4 x i32]* %305, i64 0, i64 0
store i32 %304, i32* %306
%307 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 1
%308 = getelementptr inbounds [4 x i32], [4 x i32]* %307, i64 0, i64 0
%309 = load i32, i32* %308
%310 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 1
%311 = getelementptr inbounds [4 x i32], [4 x i32]* %310, i64 0, i64 1
%312 = load i32, i32* %311
%313 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 1
%314 = getelementptr inbounds [4 x i32], [4 x i32]* %313, i64 0, i64 0
%315 = load i32, i32* %314
%316 = mul nsw i32 %312, %315
%317 = add nsw i32 %309, %316
%318 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 1
%319 = getelementptr inbounds [4 x i32], [4 x i32]* %318, i64 0, i64 0
store i32 %317, i32* %319
%320 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 1
%321 = getelementptr inbounds [4 x i32], [4 x i32]* %320, i64 0, i64 0
%322 = load i32, i32* %321
%323 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 1
%324 = getelementptr inbounds [4 x i32], [4 x i32]* %323, i64 0, i64 2
%325 = load i32, i32* %324
%326 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 2
%327 = getelementptr inbounds [4 x i32], [4 x i32]* %326, i64 0, i64 0
%328 = load i32, i32* %327
%329 = mul nsw i32 %325, %328
%330 = add nsw i32 %322, %329
%331 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 1
%332 = getelementptr inbounds [4 x i32], [4 x i32]* %331, i64 0, i64 0
store i32 %330, i32* %332
%333 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 1
%334 = getelementptr inbounds [4 x i32], [4 x i32]* %333, i64 0, i64 0
%335 = load i32, i32* %334
%336 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 1
%337 = getelementptr inbounds [4 x i32], [4 x i32]* %336, i64 0, i64 3
%338 = load i32, i32* %337
%339 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 3
%340 = getelementptr inbounds [4 x i32], [4 x i32]* %339, i64 0, i64 0
%341 = load i32, i32* %340
%342 = mul nsw i32 %338, %341
%343 = add nsw i32 %335, %342
%344 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 1
%345 = getelementptr inbounds [4 x i32], [4 x i32]* %344, i64 0, i64 0
store i32 %343, i32* %345
store i32 %343, i32* %21
%346 = load i32, i32* %21
%347 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 1
%348 = getelementptr inbounds [4 x i32], [4 x i32]* %347, i64 0, i64 1
%349 = load i32, i32* %348
%350 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 1
%351 = getelementptr inbounds [4 x i32], [4 x i32]* %350, i64 0, i64 0
%352 = load i32, i32* %351
%353 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 0
%354 = getelementptr inbounds [4 x i32], [4 x i32]* %353, i64 0, i64 1
%355 = load i32, i32* %354
%356 = mul nsw i32 %352, %355
%357 = add nsw i32 %349, %356
%358 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 1
%359 = getelementptr inbounds [4 x i32], [4 x i32]* %358, i64 0, i64 1
store i32 %357, i32* %359
%360 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 1
%361 = getelementptr inbounds [4 x i32], [4 x i32]* %360, i64 0, i64 1
%362 = load i32, i32* %361
%363 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 1
%364 = getelementptr inbounds [4 x i32], [4 x i32]* %363, i64 0, i64 1
%365 = load i32, i32* %364
%366 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 1
%367 = getelementptr inbounds [4 x i32], [4 x i32]* %366, i64 0, i64 1
%368 = load i32, i32* %367
%369 = mul nsw i32 %365, %368
%370 = add nsw i32 %362, %369
%371 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 1
%372 = getelementptr inbounds [4 x i32], [4 x i32]* %371, i64 0, i64 1
store i32 %370, i32* %372
%373 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 1
%374 = getelementptr inbounds [4 x i32], [4 x i32]* %373, i64 0, i64 1
%375 = load i32, i32* %374
%376 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 1
%377 = getelementptr inbounds [4 x i32], [4 x i32]* %376, i64 0, i64 2
%378 = load i32, i32* %377
%379 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 2
%380 = getelementptr inbounds [4 x i32], [4 x i32]* %379, i64 0, i64 1
%381 = load i32, i32* %380
%382 = mul nsw i32 %378, %381
%383 = add nsw i32 %375, %382
%384 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 1
%385 = getelementptr inbounds [4 x i32], [4 x i32]* %384, i64 0, i64 1
store i32 %383, i32* %385
%386 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 1
%387 = getelementptr inbounds [4 x i32], [4 x i32]* %386, i64 0, i64 1
%388 = load i32, i32* %387
%389 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 1
%390 = getelementptr inbounds [4 x i32], [4 x i32]* %389, i64 0, i64 3
%391 = load i32, i32* %390
%392 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 3
%393 = getelementptr inbounds [4 x i32], [4 x i32]* %392, i64 0, i64 1
%394 = load i32, i32* %393
%395 = mul nsw i32 %391, %394
%396 = add nsw i32 %388, %395
%397 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 1
%398 = getelementptr inbounds [4 x i32], [4 x i32]* %397, i64 0, i64 1
store i32 %396, i32* %398
store i32 %396, i32* %22
%399 = load i32, i32* %22
%400 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 1
%401 = getelementptr inbounds [4 x i32], [4 x i32]* %400, i64 0, i64 2
%402 = load i32, i32* %401
%403 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 1
%404 = getelementptr inbounds [4 x i32], [4 x i32]* %403, i64 0, i64 0
%405 = load i32, i32* %404
%406 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 0
%407 = getelementptr inbounds [4 x i32], [4 x i32]* %406, i64 0, i64 2
%408 = load i32, i32* %407
%409 = mul nsw i32 %405, %408
%410 = add nsw i32 %402, %409
%411 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 1
%412 = getelementptr inbounds [4 x i32], [4 x i32]* %411, i64 0, i64 2
store i32 %410, i32* %412
%413 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 1
%414 = getelementptr inbounds [4 x i32], [4 x i32]* %413, i64 0, i64 2
%415 = load i32, i32* %414
%416 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 1
%417 = getelementptr inbounds [4 x i32], [4 x i32]* %416, i64 0, i64 1
%418 = load i32, i32* %417
%419 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 1
%420 = getelementptr inbounds [4 x i32], [4 x i32]* %419, i64 0, i64 2
%421 = load i32, i32* %420
%422 = mul nsw i32 %418, %421
%423 = add nsw i32 %415, %422
%424 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 1
%425 = getelementptr inbounds [4 x i32], [4 x i32]* %424, i64 0, i64 2
store i32 %423, i32* %425
%426 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 1
%427 = getelementptr inbounds [4 x i32], [4 x i32]* %426, i64 0, i64 2
%428 = load i32, i32* %427
%429 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 1
%430 = getelementptr inbounds [4 x i32], [4 x i32]* %429, i64 0, i64 2
%431 = load i32, i32* %430
%432 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 2
%433 = getelementptr inbounds [4 x i32], [4 x i32]* %432, i64 0, i64 2
%434 = load i32, i32* %433
%435 = mul nsw i32 %431, %434
%436 = add nsw i32 %428, %435
%437 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 1
%438 = getelementptr inbounds [4 x i32], [4 x i32]* %437, i64 0, i64 2
store i32 %436, i32* %438
%439 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 1
%440 = getelementptr inbounds [4 x i32], [4 x i32]* %439, i64 0, i64 2
%441 = load i32, i32* %440
%442 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 1
%443 = getelementptr inbounds [4 x i32], [4 x i32]* %442, i64 0, i64 3
%444 = load i32, i32* %443
%445 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 3
%446 = getelementptr inbounds [4 x i32], [4 x i32]* %445, i64 0, i64 2
%447 = load i32, i32* %446
%448 = mul nsw i32 %444, %447
%449 = add nsw i32 %441, %448
%450 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 1
%451 = getelementptr inbounds [4 x i32], [4 x i32]* %450, i64 0, i64 2
store i32 %449, i32* %451
store i32 %449, i32* %23
%452 = load i32, i32* %23
%453 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 1
%454 = getelementptr inbounds [4 x i32], [4 x i32]* %453, i64 0, i64 3
%455 = load i32, i32* %454
%456 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 1
%457 = getelementptr inbounds [4 x i32], [4 x i32]* %456, i64 0, i64 0
%458 = load i32, i32* %457
%459 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 0
%460 = getelementptr inbounds [4 x i32], [4 x i32]* %459, i64 0, i64 3
%461 = load i32, i32* %460
%462 = mul nsw i32 %458, %461
%463 = add nsw i32 %455, %462
%464 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 1
%465 = getelementptr inbounds [4 x i32], [4 x i32]* %464, i64 0, i64 3
store i32 %463, i32* %465
%466 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 1
%467 = getelementptr inbounds [4 x i32], [4 x i32]* %466, i64 0, i64 3
%468 = load i32, i32* %467
%469 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 1
%470 = getelementptr inbounds [4 x i32], [4 x i32]* %469, i64 0, i64 1
%471 = load i32, i32* %470
%472 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 1
%473 = getelementptr inbounds [4 x i32], [4 x i32]* %472, i64 0, i64 3
%474 = load i32, i32* %473
%475 = mul nsw i32 %471, %474
%476 = add nsw i32 %468, %475
%477 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 1
%478 = getelementptr inbounds [4 x i32], [4 x i32]* %477, i64 0, i64 3
store i32 %476, i32* %478
%479 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 1
%480 = getelementptr inbounds [4 x i32], [4 x i32]* %479, i64 0, i64 3
%481 = load i32, i32* %480
%482 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 1
%483 = getelementptr inbounds [4 x i32], [4 x i32]* %482, i64 0, i64 2
%484 = load i32, i32* %483
%485 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 2
%486 = getelementptr inbounds [4 x i32], [4 x i32]* %485, i64 0, i64 3
%487 = load i32, i32* %486
%488 = mul nsw i32 %484, %487
%489 = add nsw i32 %481, %488
%490 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 1
%491 = getelementptr inbounds [4 x i32], [4 x i32]* %490, i64 0, i64 3
store i32 %489, i32* %491
%492 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 1
%493 = getelementptr inbounds [4 x i32], [4 x i32]* %492, i64 0, i64 3
%494 = load i32, i32* %493
%495 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 1
%496 = getelementptr inbounds [4 x i32], [4 x i32]* %495, i64 0, i64 3
%497 = load i32, i32* %496
%498 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 3
%499 = getelementptr inbounds [4 x i32], [4 x i32]* %498, i64 0, i64 3
%500 = load i32, i32* %499
%501 = mul nsw i32 %497, %500
%502 = add nsw i32 %494, %501
%503 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 1
%504 = getelementptr inbounds [4 x i32], [4 x i32]* %503, i64 0, i64 3
store i32 %502, i32* %504
store i32 %502, i32* %25
%505 = load i32, i32* %25
store i32 %505, i32* %24
%506 = load i32, i32* %24
%507 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 2
%508 = getelementptr inbounds [4 x i32], [4 x i32]* %507, i64 0, i64 0
%509 = load i32, i32* %508
%510 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 2
%511 = getelementptr inbounds [4 x i32], [4 x i32]* %510, i64 0, i64 0
%512 = load i32, i32* %511
%513 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 0
%514 = getelementptr inbounds [4 x i32], [4 x i32]* %513, i64 0, i64 0
%515 = load i32, i32* %514
%516 = mul nsw i32 %512, %515
%517 = add nsw i32 %509, %516
%518 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 2
%519 = getelementptr inbounds [4 x i32], [4 x i32]* %518, i64 0, i64 0
store i32 %517, i32* %519
%520 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 2
%521 = getelementptr inbounds [4 x i32], [4 x i32]* %520, i64 0, i64 0
%522 = load i32, i32* %521
%523 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 2
%524 = getelementptr inbounds [4 x i32], [4 x i32]* %523, i64 0, i64 1
%525 = load i32, i32* %524
%526 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 1
%527 = getelementptr inbounds [4 x i32], [4 x i32]* %526, i64 0, i64 0
%528 = load i32, i32* %527
%529 = mul nsw i32 %525, %528
%530 = add nsw i32 %522, %529
%531 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 2
%532 = getelementptr inbounds [4 x i32], [4 x i32]* %531, i64 0, i64 0
store i32 %530, i32* %532
%533 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 2
%534 = getelementptr inbounds [4 x i32], [4 x i32]* %533, i64 0, i64 0
%535 = load i32, i32* %534
%536 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 2
%537 = getelementptr inbounds [4 x i32], [4 x i32]* %536, i64 0, i64 2
%538 = load i32, i32* %537
%539 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 2
%540 = getelementptr inbounds [4 x i32], [4 x i32]* %539, i64 0, i64 0
%541 = load i32, i32* %540
%542 = mul nsw i32 %538, %541
%543 = add nsw i32 %535, %542
%544 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 2
%545 = getelementptr inbounds [4 x i32], [4 x i32]* %544, i64 0, i64 0
store i32 %543, i32* %545
%546 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 2
%547 = getelementptr inbounds [4 x i32], [4 x i32]* %546, i64 0, i64 0
%548 = load i32, i32* %547
%549 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 2
%550 = getelementptr inbounds [4 x i32], [4 x i32]* %549, i64 0, i64 3
%551 = load i32, i32* %550
%552 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 3
%553 = getelementptr inbounds [4 x i32], [4 x i32]* %552, i64 0, i64 0
%554 = load i32, i32* %553
%555 = mul nsw i32 %551, %554
%556 = add nsw i32 %548, %555
%557 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 2
%558 = getelementptr inbounds [4 x i32], [4 x i32]* %557, i64 0, i64 0
store i32 %556, i32* %558
store i32 %556, i32* %26
%559 = load i32, i32* %26
%560 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 2
%561 = getelementptr inbounds [4 x i32], [4 x i32]* %560, i64 0, i64 1
%562 = load i32, i32* %561
%563 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 2
%564 = getelementptr inbounds [4 x i32], [4 x i32]* %563, i64 0, i64 0
%565 = load i32, i32* %564
%566 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 0
%567 = getelementptr inbounds [4 x i32], [4 x i32]* %566, i64 0, i64 1
%568 = load i32, i32* %567
%569 = mul nsw i32 %565, %568
%570 = add nsw i32 %562, %569
%571 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 2
%572 = getelementptr inbounds [4 x i32], [4 x i32]* %571, i64 0, i64 1
store i32 %570, i32* %572
%573 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 2
%574 = getelementptr inbounds [4 x i32], [4 x i32]* %573, i64 0, i64 1
%575 = load i32, i32* %574
%576 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 2
%577 = getelementptr inbounds [4 x i32], [4 x i32]* %576, i64 0, i64 1
%578 = load i32, i32* %577
%579 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 1
%580 = getelementptr inbounds [4 x i32], [4 x i32]* %579, i64 0, i64 1
%581 = load i32, i32* %580
%582 = mul nsw i32 %578, %581
%583 = add nsw i32 %575, %582
%584 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 2
%585 = getelementptr inbounds [4 x i32], [4 x i32]* %584, i64 0, i64 1
store i32 %583, i32* %585
%586 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 2
%587 = getelementptr inbounds [4 x i32], [4 x i32]* %586, i64 0, i64 1
%588 = load i32, i32* %587
%589 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 2
%590 = getelementptr inbounds [4 x i32], [4 x i32]* %589, i64 0, i64 2
%591 = load i32, i32* %590
%592 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 2
%593 = getelementptr inbounds [4 x i32], [4 x i32]* %592, i64 0, i64 1
%594 = load i32, i32* %593
%595 = mul nsw i32 %591, %594
%596 = add nsw i32 %588, %595
%597 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 2
%598 = getelementptr inbounds [4 x i32], [4 x i32]* %597, i64 0, i64 1
store i32 %596, i32* %598
%599 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 2
%600 = getelementptr inbounds [4 x i32], [4 x i32]* %599, i64 0, i64 1
%601 = load i32, i32* %600
%602 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 2
%603 = getelementptr inbounds [4 x i32], [4 x i32]* %602, i64 0, i64 3
%604 = load i32, i32* %603
%605 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 3
%606 = getelementptr inbounds [4 x i32], [4 x i32]* %605, i64 0, i64 1
%607 = load i32, i32* %606
%608 = mul nsw i32 %604, %607
%609 = add nsw i32 %601, %608
%610 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 2
%611 = getelementptr inbounds [4 x i32], [4 x i32]* %610, i64 0, i64 1
store i32 %609, i32* %611
store i32 %609, i32* %27
%612 = load i32, i32* %27
%613 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 2
%614 = getelementptr inbounds [4 x i32], [4 x i32]* %613, i64 0, i64 2
%615 = load i32, i32* %614
%616 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 2
%617 = getelementptr inbounds [4 x i32], [4 x i32]* %616, i64 0, i64 0
%618 = load i32, i32* %617
%619 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 0
%620 = getelementptr inbounds [4 x i32], [4 x i32]* %619, i64 0, i64 2
%621 = load i32, i32* %620
%622 = mul nsw i32 %618, %621
%623 = add nsw i32 %615, %622
%624 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 2
%625 = getelementptr inbounds [4 x i32], [4 x i32]* %624, i64 0, i64 2
store i32 %623, i32* %625
%626 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 2
%627 = getelementptr inbounds [4 x i32], [4 x i32]* %626, i64 0, i64 2
%628 = load i32, i32* %627
%629 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 2
%630 = getelementptr inbounds [4 x i32], [4 x i32]* %629, i64 0, i64 1
%631 = load i32, i32* %630
%632 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 1
%633 = getelementptr inbounds [4 x i32], [4 x i32]* %632, i64 0, i64 2
%634 = load i32, i32* %633
%635 = mul nsw i32 %631, %634
%636 = add nsw i32 %628, %635
%637 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 2
%638 = getelementptr inbounds [4 x i32], [4 x i32]* %637, i64 0, i64 2
store i32 %636, i32* %638
%639 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 2
%640 = getelementptr inbounds [4 x i32], [4 x i32]* %639, i64 0, i64 2
%641 = load i32, i32* %640
%642 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 2
%643 = getelementptr inbounds [4 x i32], [4 x i32]* %642, i64 0, i64 2
%644 = load i32, i32* %643
%645 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 2
%646 = getelementptr inbounds [4 x i32], [4 x i32]* %645, i64 0, i64 2
%647 = load i32, i32* %646
%648 = mul nsw i32 %644, %647
%649 = add nsw i32 %641, %648
%650 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 2
%651 = getelementptr inbounds [4 x i32], [4 x i32]* %650, i64 0, i64 2
store i32 %649, i32* %651
%652 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 2
%653 = getelementptr inbounds [4 x i32], [4 x i32]* %652, i64 0, i64 2
%654 = load i32, i32* %653
%655 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 2
%656 = getelementptr inbounds [4 x i32], [4 x i32]* %655, i64 0, i64 3
%657 = load i32, i32* %656
%658 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 3
%659 = getelementptr inbounds [4 x i32], [4 x i32]* %658, i64 0, i64 2
%660 = load i32, i32* %659
%661 = mul nsw i32 %657, %660
%662 = add nsw i32 %654, %661
%663 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 2
%664 = getelementptr inbounds [4 x i32], [4 x i32]* %663, i64 0, i64 2
store i32 %662, i32* %664
store i32 %662, i32* %28
%665 = load i32, i32* %28
%666 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 2
%667 = getelementptr inbounds [4 x i32], [4 x i32]* %666, i64 0, i64 3
%668 = load i32, i32* %667
%669 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 2
%670 = getelementptr inbounds [4 x i32], [4 x i32]* %669, i64 0, i64 0
%671 = load i32, i32* %670
%672 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 0
%673 = getelementptr inbounds [4 x i32], [4 x i32]* %672, i64 0, i64 3
%674 = load i32, i32* %673
%675 = mul nsw i32 %671, %674
%676 = add nsw i32 %668, %675
%677 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 2
%678 = getelementptr inbounds [4 x i32], [4 x i32]* %677, i64 0, i64 3
store i32 %676, i32* %678
%679 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 2
%680 = getelementptr inbounds [4 x i32], [4 x i32]* %679, i64 0, i64 3
%681 = load i32, i32* %680
%682 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 2
%683 = getelementptr inbounds [4 x i32], [4 x i32]* %682, i64 0, i64 1
%684 = load i32, i32* %683
%685 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 1
%686 = getelementptr inbounds [4 x i32], [4 x i32]* %685, i64 0, i64 3
%687 = load i32, i32* %686
%688 = mul nsw i32 %684, %687
%689 = add nsw i32 %681, %688
%690 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 2
%691 = getelementptr inbounds [4 x i32], [4 x i32]* %690, i64 0, i64 3
store i32 %689, i32* %691
%692 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 2
%693 = getelementptr inbounds [4 x i32], [4 x i32]* %692, i64 0, i64 3
%694 = load i32, i32* %693
%695 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 2
%696 = getelementptr inbounds [4 x i32], [4 x i32]* %695, i64 0, i64 2
%697 = load i32, i32* %696
%698 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 2
%699 = getelementptr inbounds [4 x i32], [4 x i32]* %698, i64 0, i64 3
%700 = load i32, i32* %699
%701 = mul nsw i32 %697, %700
%702 = add nsw i32 %694, %701
%703 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 2
%704 = getelementptr inbounds [4 x i32], [4 x i32]* %703, i64 0, i64 3
store i32 %702, i32* %704
%705 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 2
%706 = getelementptr inbounds [4 x i32], [4 x i32]* %705, i64 0, i64 3
%707 = load i32, i32* %706
%708 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 2
%709 = getelementptr inbounds [4 x i32], [4 x i32]* %708, i64 0, i64 3
%710 = load i32, i32* %709
%711 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 3
%712 = getelementptr inbounds [4 x i32], [4 x i32]* %711, i64 0, i64 3
%713 = load i32, i32* %712
%714 = mul nsw i32 %710, %713
%715 = add nsw i32 %707, %714
%716 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 2
%717 = getelementptr inbounds [4 x i32], [4 x i32]* %716, i64 0, i64 3
store i32 %715, i32* %717
store i32 %715, i32* %30
%718 = load i32, i32* %30
store i32 %718, i32* %29
%719 = load i32, i32* %29
%720 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 3
%721 = getelementptr inbounds [4 x i32], [4 x i32]* %720, i64 0, i64 0
%722 = load i32, i32* %721
%723 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 3
%724 = getelementptr inbounds [4 x i32], [4 x i32]* %723, i64 0, i64 0
%725 = load i32, i32* %724
%726 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 0
%727 = getelementptr inbounds [4 x i32], [4 x i32]* %726, i64 0, i64 0
%728 = load i32, i32* %727
%729 = mul nsw i32 %725, %728
%730 = add nsw i32 %722, %729
%731 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 3
%732 = getelementptr inbounds [4 x i32], [4 x i32]* %731, i64 0, i64 0
store i32 %730, i32* %732
%733 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 3
%734 = getelementptr inbounds [4 x i32], [4 x i32]* %733, i64 0, i64 0
%735 = load i32, i32* %734
%736 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 3
%737 = getelementptr inbounds [4 x i32], [4 x i32]* %736, i64 0, i64 1
%738 = load i32, i32* %737
%739 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 1
%740 = getelementptr inbounds [4 x i32], [4 x i32]* %739, i64 0, i64 0
%741 = load i32, i32* %740
%742 = mul nsw i32 %738, %741
%743 = add nsw i32 %735, %742
%744 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 3
%745 = getelementptr inbounds [4 x i32], [4 x i32]* %744, i64 0, i64 0
store i32 %743, i32* %745
%746 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 3
%747 = getelementptr inbounds [4 x i32], [4 x i32]* %746, i64 0, i64 0
%748 = load i32, i32* %747
%749 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 3
%750 = getelementptr inbounds [4 x i32], [4 x i32]* %749, i64 0, i64 2
%751 = load i32, i32* %750
%752 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 2
%753 = getelementptr inbounds [4 x i32], [4 x i32]* %752, i64 0, i64 0
%754 = load i32, i32* %753
%755 = mul nsw i32 %751, %754
%756 = add nsw i32 %748, %755
%757 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 3
%758 = getelementptr inbounds [4 x i32], [4 x i32]* %757, i64 0, i64 0
store i32 %756, i32* %758
%759 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 3
%760 = getelementptr inbounds [4 x i32], [4 x i32]* %759, i64 0, i64 0
%761 = load i32, i32* %760
%762 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 3
%763 = getelementptr inbounds [4 x i32], [4 x i32]* %762, i64 0, i64 3
%764 = load i32, i32* %763
%765 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 3
%766 = getelementptr inbounds [4 x i32], [4 x i32]* %765, i64 0, i64 0
%767 = load i32, i32* %766
%768 = mul nsw i32 %764, %767
%769 = add nsw i32 %761, %768
%770 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 3
%771 = getelementptr inbounds [4 x i32], [4 x i32]* %770, i64 0, i64 0
store i32 %769, i32* %771
store i32 %769, i32* %32
%772 = load i32, i32* %32
%773 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 3
%774 = getelementptr inbounds [4 x i32], [4 x i32]* %773, i64 0, i64 1
%775 = load i32, i32* %774
%776 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 3
%777 = getelementptr inbounds [4 x i32], [4 x i32]* %776, i64 0, i64 0
%778 = load i32, i32* %777
%779 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 0
%780 = getelementptr inbounds [4 x i32], [4 x i32]* %779, i64 0, i64 1
%781 = load i32, i32* %780
%782 = mul nsw i32 %778, %781
%783 = add nsw i32 %775, %782
%784 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 3
%785 = getelementptr inbounds [4 x i32], [4 x i32]* %784, i64 0, i64 1
store i32 %783, i32* %785
%786 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 3
%787 = getelementptr inbounds [4 x i32], [4 x i32]* %786, i64 0, i64 1
%788 = load i32, i32* %787
%789 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 3
%790 = getelementptr inbounds [4 x i32], [4 x i32]* %789, i64 0, i64 1
%791 = load i32, i32* %790
%792 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 1
%793 = getelementptr inbounds [4 x i32], [4 x i32]* %792, i64 0, i64 1
%794 = load i32, i32* %793
%795 = mul nsw i32 %791, %794
%796 = add nsw i32 %788, %795
%797 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 3
%798 = getelementptr inbounds [4 x i32], [4 x i32]* %797, i64 0, i64 1
store i32 %796, i32* %798
%799 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 3
%800 = getelementptr inbounds [4 x i32], [4 x i32]* %799, i64 0, i64 1
%801 = load i32, i32* %800
%802 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 3
%803 = getelementptr inbounds [4 x i32], [4 x i32]* %802, i64 0, i64 2
%804 = load i32, i32* %803
%805 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 2
%806 = getelementptr inbounds [4 x i32], [4 x i32]* %805, i64 0, i64 1
%807 = load i32, i32* %806
%808 = mul nsw i32 %804, %807
%809 = add nsw i32 %801, %808
%810 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 3
%811 = getelementptr inbounds [4 x i32], [4 x i32]* %810, i64 0, i64 1
store i32 %809, i32* %811
%812 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 3
%813 = getelementptr inbounds [4 x i32], [4 x i32]* %812, i64 0, i64 1
%814 = load i32, i32* %813
%815 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 3
%816 = getelementptr inbounds [4 x i32], [4 x i32]* %815, i64 0, i64 3
%817 = load i32, i32* %816
%818 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 3
%819 = getelementptr inbounds [4 x i32], [4 x i32]* %818, i64 0, i64 1
%820 = load i32, i32* %819
%821 = mul nsw i32 %817, %820
%822 = add nsw i32 %814, %821
%823 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 3
%824 = getelementptr inbounds [4 x i32], [4 x i32]* %823, i64 0, i64 1
store i32 %822, i32* %824
store i32 %822, i32* %33
%825 = load i32, i32* %33
%826 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 3
%827 = getelementptr inbounds [4 x i32], [4 x i32]* %826, i64 0, i64 2
%828 = load i32, i32* %827
%829 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 3
%830 = getelementptr inbounds [4 x i32], [4 x i32]* %829, i64 0, i64 0
%831 = load i32, i32* %830
%832 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 0
%833 = getelementptr inbounds [4 x i32], [4 x i32]* %832, i64 0, i64 2
%834 = load i32, i32* %833
%835 = mul nsw i32 %831, %834
%836 = add nsw i32 %828, %835
%837 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 3
%838 = getelementptr inbounds [4 x i32], [4 x i32]* %837, i64 0, i64 2
store i32 %836, i32* %838
%839 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 3
%840 = getelementptr inbounds [4 x i32], [4 x i32]* %839, i64 0, i64 2
%841 = load i32, i32* %840
%842 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 3
%843 = getelementptr inbounds [4 x i32], [4 x i32]* %842, i64 0, i64 1
%844 = load i32, i32* %843
%845 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 1
%846 = getelementptr inbounds [4 x i32], [4 x i32]* %845, i64 0, i64 2
%847 = load i32, i32* %846
%848 = mul nsw i32 %844, %847
%849 = add nsw i32 %841, %848
%850 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 3
%851 = getelementptr inbounds [4 x i32], [4 x i32]* %850, i64 0, i64 2
store i32 %849, i32* %851
%852 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 3
%853 = getelementptr inbounds [4 x i32], [4 x i32]* %852, i64 0, i64 2
%854 = load i32, i32* %853
%855 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 3
%856 = getelementptr inbounds [4 x i32], [4 x i32]* %855, i64 0, i64 2
%857 = load i32, i32* %856
%858 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 2
%859 = getelementptr inbounds [4 x i32], [4 x i32]* %858, i64 0, i64 2
%860 = load i32, i32* %859
%861 = mul nsw i32 %857, %860
%862 = add nsw i32 %854, %861
%863 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 3
%864 = getelementptr inbounds [4 x i32], [4 x i32]* %863, i64 0, i64 2
store i32 %862, i32* %864
%865 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 3
%866 = getelementptr inbounds [4 x i32], [4 x i32]* %865, i64 0, i64 2
%867 = load i32, i32* %866
%868 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 3
%869 = getelementptr inbounds [4 x i32], [4 x i32]* %868, i64 0, i64 3
%870 = load i32, i32* %869
%871 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 3
%872 = getelementptr inbounds [4 x i32], [4 x i32]* %871, i64 0, i64 2
%873 = load i32, i32* %872
%874 = mul nsw i32 %870, %873
%875 = add nsw i32 %867, %874
%876 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 3
%877 = getelementptr inbounds [4 x i32], [4 x i32]* %876, i64 0, i64 2
store i32 %875, i32* %877
store i32 %875, i32* %34
%878 = load i32, i32* %34
%879 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 3
%880 = getelementptr inbounds [4 x i32], [4 x i32]* %879, i64 0, i64 3
%881 = load i32, i32* %880
%882 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 3
%883 = getelementptr inbounds [4 x i32], [4 x i32]* %882, i64 0, i64 0
%884 = load i32, i32* %883
%885 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 0
%886 = getelementptr inbounds [4 x i32], [4 x i32]* %885, i64 0, i64 3
%887 = load i32, i32* %886
%888 = mul nsw i32 %884, %887
%889 = add nsw i32 %881, %888
%890 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 3
%891 = getelementptr inbounds [4 x i32], [4 x i32]* %890, i64 0, i64 3
store i32 %889, i32* %891
%892 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 3
%893 = getelementptr inbounds [4 x i32], [4 x i32]* %892, i64 0, i64 3
%894 = load i32, i32* %893
%895 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 3
%896 = getelementptr inbounds [4 x i32], [4 x i32]* %895, i64 0, i64 1
%897 = load i32, i32* %896
%898 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 1
%899 = getelementptr inbounds [4 x i32], [4 x i32]* %898, i64 0, i64 3
%900 = load i32, i32* %899
%901 = mul nsw i32 %897, %900
%902 = add nsw i32 %894, %901
%903 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 3
%904 = getelementptr inbounds [4 x i32], [4 x i32]* %903, i64 0, i64 3
store i32 %902, i32* %904
%905 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 3
%906 = getelementptr inbounds [4 x i32], [4 x i32]* %905, i64 0, i64 3
%907 = load i32, i32* %906
%908 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 3
%909 = getelementptr inbounds [4 x i32], [4 x i32]* %908, i64 0, i64 2
%910 = load i32, i32* %909
%911 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 2
%912 = getelementptr inbounds [4 x i32], [4 x i32]* %911, i64 0, i64 3
%913 = load i32, i32* %912
%914 = mul nsw i32 %910, %913
%915 = add nsw i32 %907, %914
%916 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 3
%917 = getelementptr inbounds [4 x i32], [4 x i32]* %916, i64 0, i64 3
store i32 %915, i32* %917
%918 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 3
%919 = getelementptr inbounds [4 x i32], [4 x i32]* %918, i64 0, i64 3
%920 = load i32, i32* %919
%921 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %6, i64 0, i64 3
%922 = getelementptr inbounds [4 x i32], [4 x i32]* %921, i64 0, i64 3
%923 = load i32, i32* %922
%924 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %7, i64 0, i64 3
%925 = getelementptr inbounds [4 x i32], [4 x i32]* %924, i64 0, i64 3
%926 = load i32, i32* %925
%927 = mul nsw i32 %923, %926
%928 = add nsw i32 %920, %927
%929 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 3
%930 = getelementptr inbounds [4 x i32], [4 x i32]* %929, i64 0, i64 3
store i32 %928, i32* %930
store i32 %928, i32* %36
%931 = load i32, i32* %36
store i32 %931, i32* %35
%932 = load i32, i32* %35
store i32 %932, i32* %31
%933 = load i32, i32* %31
br label %934
934: ; preds = %80
%935 = load i32, i32* %12
%936 = add nsw i32 %935, 1
store i32 %936, i32* %12
br label %76
937: ; preds = %76
%938 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 0
%939 = call i32 ([4 x i32]*, ...) bitcast (i32 (...)* @print_matriu to i32 ([4 x i32]*, ...)*)([4 x i32]* %938)
ret i32 0
}

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