#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */
typedef double uint64_t;
struct timespec {
  long tv_sec;
  double tv_nsec;
};

/* Variables and functions */
int /*<<< orphan*/ CLOCK_MONOTONIC;
int atoi(char *);
scalar_t__ calloc(int, int);
int /*<<< orphan*/ clock_gettime(int /*<<< orphan*/, struct timespec *);
int /*<<< orphan*/ printf(char *, float, ...);
double rand();
int /*<<< orphan*/ srand(int /*<<< orphan*/);
int /*<<< orphan*/ time(int /*<<< orphan*/ *);
int main(int argc, char *argv[]) {
  int n = atoi(argv[1]);
  uint64_t t0;
  float t;
  struct timespec begin, end;
  double *a, *b;
  double *c;
  int *a1, *b1, *c1;
  double diff;
  int CACHE_SIZE = 4;
  int LINE_SIZE = 4;
  int i, j, k;
  srand(time(NULL));
  a = (double *)calloc(sizeof(double), n * n);
  for (i = 0; i < n * n; i++) {
    a[i] = rand() / 1000000.0;
  }
  b = (double *)calloc(sizeof(double), n * n);
  for (i = 0; i < n * n; i++) {
    b[i] = rand() / 1000000.0;
  }
  c = (double *)calloc(sizeof(double), n * n);
  for (i = 0; i < n * n; i++) {
    c[i] = 0.0;
  }
  a1 = (int *)calloc(sizeof(int), n * n);
  for (i = 0; i < n * n; i++) {
    a1[i] = 0;
  }
  b1 = (int *)calloc(sizeof(int), n * n);
  for (i = 0; i < n * n; i++) {
    b1[i] = 0;
  }
  c1 = (int *)calloc(sizeof(int), n * n);
  for (i = 0; i < n * n; i++) {
    c1[i] = 0;
  }
  clock_gettime(CLOCK_MONOTONIC, &begin);
  for (i = 0; i < n; i++) {
    for (j = 0; j < n; j++) {
      register double r = c[i * n + j];
      c1[i * n + j]++;
      printf("Reading C[%d,%d] %d\n", (i * n + j) / n, j, c1[i * n + j]);
      for (k = 0; k < n; k++) {
        r += a[i * n + k] * b[k * n + j];
        a1[i * n + k]++;
        b1[k * n + j]++;
        printf("Reading A[%d,%d] %d\n", (i * n + k) / n, k, a1[i * n + k]);
        printf("Reading B[%d,%d] %d\n", (k * n + j) / n, j, b1[k * n + j]);
      }
      c[i * n + j] = r;
    }
  }
  for (i = 0; i < n; i++) {
    for (j = 0; j < n; j++) {
      printf("Pos (%d,%d) -> C: %d \t A: %d \t B: %d\n", i, j, c1[i * n + j],
             a1[i * n + j], b1[i * n + j]);
    }
  }
  clock_gettime(CLOCK_MONOTONIC, &end);
  t0 = 1000000000L * (end.tv_sec - begin.tv_sec) + end.tv_nsec - begin.tv_nsec;
  t = t0 / 1000000000.0;
  printf("%f\n", t);
  for (i = 0; i < n * n; i++) {
    a1[i] = 0;
  }
  b1 = (int *)calloc(sizeof(int), n * n);
  for (i = 0; i < n * n; i++) {
    b1[i] = 0;
  }
  c1 = (int *)calloc(sizeof(int), n * n);
  for (i = 0; i < n * n; i++) {
    c1[i] = 0;
  }
  clock_gettime(CLOCK_MONOTONIC, &begin);
  for (k = 0; k < n; k++) {
    for (i = 0; i < n; i++) {
      register double r = a[i * n + k];
      a1[i * n + k]++;
      printf("Reading A[%d,%d] %d\n", (i * n + k) / n, k, a1[i * n + k]);
      for (j = 0; j < n; j++) {
        c[i * n + j] += r * b[k * n + j];
        c1[i * n + j]++;
        b1[k * n + j]++;
        printf("Reading C[%d,%d] %d\n", (i * n + j) / n, j, c1[i * n + j]);
        printf("Reading B[%d,%d] %d\n", (k * n + j) / n, j, b1[k * n + j]);
      }
    }
  }
  for (i = 0; i < n; i++) {
    for (j = 0; j < n; j++) {
      printf("Pos (%d,%d) -> C: %d \t A: %d \t B: %d\n", i, j, c1[i * n + j],
             a1[i * n + j], b1[i * n + j]);
    }
  }
  clock_gettime(CLOCK_MONOTONIC, &end);
  t0 = 1000000000L * (end.tv_sec - begin.tv_sec) + end.tv_nsec - begin.tv_nsec;
  t = t0 / 1000000000.0;
  printf("%f\n", t);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rdi
call   1080 <atoi@plt>
mov    %eax,-0x14(%rbp)
movl   $0x4,-0x84(%rbp)
movl   $0x4,-0x88(%rbp)
xor    %eax,%eax
mov    %eax,%edi
call   1070 <time@plt>
mov    %eax,%edi
call   1050 <srand@plt>
mov    -0x14(%rbp),%esi
imul   -0x14(%rbp),%esi
mov    $0x8,%edi
call   1060 <calloc@plt>
mov    %rax,-0x50(%rbp)
movl   $0x0,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
mov    -0x14(%rbp),%ecx
imul   -0x14(%rbp),%ecx
cmp    %ecx,%eax
jge    1228 <main+0xb8>
mov    $0x0,%al
call   1090 <rand@plt>
movsd  0xe08(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    -0x50(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    11dc <main+0x6c>
mov    -0x14(%rbp),%esi
imul   -0x14(%rbp),%esi
mov    $0x8,%edi
call   1060 <calloc@plt>
mov    %rax,-0x58(%rbp)
movl   $0x0,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
mov    -0x14(%rbp),%ecx
imul   -0x14(%rbp),%ecx
cmp    %ecx,%eax
jge    1293 <main+0x123>
mov    $0x0,%al
call   1090 <rand@plt>
movsd  0xd9d(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    -0x58(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    1247 <main+0xd7>
mov    -0x14(%rbp),%esi
imul   -0x14(%rbp),%esi
mov    $0x8,%edi
call   1060 <calloc@plt>
mov    %rax,-0x60(%rbp)
movl   $0x0,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
mov    -0x14(%rbp),%ecx
imul   -0x14(%rbp),%ecx
cmp    %ecx,%eax
jge    12ee <main+0x17e>
mov    -0x60(%rbp),%rax
movslq -0x8c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    12b2 <main+0x142>
mov    -0x14(%rbp),%esi
imul   -0x14(%rbp),%esi
mov    $0x4,%edi
call   1060 <calloc@plt>
mov    %rax,-0x68(%rbp)
movl   $0x0,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
mov    -0x14(%rbp),%ecx
imul   -0x14(%rbp),%ecx
cmp    %ecx,%eax
jge    1348 <main+0x1d8>
mov    -0x68(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    130d <main+0x19d>
mov    -0x14(%rbp),%esi
imul   -0x14(%rbp),%esi
mov    $0x4,%edi
call   1060 <calloc@plt>
mov    %rax,-0x70(%rbp)
movl   $0x0,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
mov    -0x14(%rbp),%ecx
imul   -0x14(%rbp),%ecx
cmp    %ecx,%eax
jge    13a2 <main+0x232>
mov    -0x70(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    1367 <main+0x1f7>
mov    -0x14(%rbp),%esi
imul   -0x14(%rbp),%esi
mov    $0x4,%edi
call   1060 <calloc@plt>
mov    %rax,-0x78(%rbp)
movl   $0x0,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
mov    -0x14(%rbp),%ecx
imul   -0x14(%rbp),%ecx
cmp    %ecx,%eax
jge    13fc <main+0x28c>
mov    -0x78(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    13c1 <main+0x251>
mov    0x2be5(%rip),%rax
mov    (%rax),%edi
lea    -0x38(%rbp),%rsi
call   1030 <clock_gettime@plt>
movl   $0x0,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1664 <main+0x4f4>
movl   $0x0,-0x90(%rbp)
mov    -0x90(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    164b <main+0x4db>
mov    -0x60(%rbp),%rax
mov    -0x8c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x90(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x78(%rbp),%rax
mov    -0x8c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x90(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x8c(%rbp),%eax
imul   -0x14(%rbp),%eax
add    -0x90(%rbp),%eax
cltd
idivl  -0x14(%rbp)
cvtsi2ss %eax,%xmm0
mov    -0x90(%rbp),%esi
mov    -0x78(%rbp),%rax
mov    -0x8c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x90(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
lea    0xb4d(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1613 <main+0x4a3>
mov    -0x50(%rbp),%rax
mov    -0x8c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x94(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
mov    -0x94(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x90(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xa0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x68(%rbp),%rax
mov    -0x8c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x94(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x70(%rbp),%rax
mov    -0x94(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x90(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x8c(%rbp),%eax
imul   -0x14(%rbp),%eax
add    -0x94(%rbp),%eax
cltd
idivl  -0x14(%rbp)
cvtsi2ss %eax,%xmm0
mov    -0x94(%rbp),%esi
mov    -0x68(%rbp),%rax
mov    -0x8c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x94(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
lea    0xa73(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    -0x94(%rbp),%eax
imul   -0x14(%rbp),%eax
add    -0x90(%rbp),%eax
cltd
idivl  -0x14(%rbp)
cvtsi2ss %eax,%xmm0
mov    -0x90(%rbp),%esi
mov    -0x70(%rbp),%rax
mov    -0x94(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x90(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
lea    0xa42(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    14d4 <main+0x364>
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x60(%rbp),%rax
mov    -0x8c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x90(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x90(%rbp)
jmp    1431 <main+0x2c1>
jmp    1650 <main+0x4e0>
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    1418 <main+0x2a8>
movl   $0x0,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    172e <main+0x5be>
movl   $0x0,-0x90(%rbp)
mov    -0x90(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1715 <main+0x5a5>
cvtsi2ssl -0x8c(%rbp),%xmm0
ff
mov    -0x90(%rbp),%esi
mov    -0x78(%rbp),%rax
mov    -0x8c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x90(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x68(%rbp),%rax
mov    -0x8c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x90(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%ecx
mov    -0x70(%rbp),%rax
mov    -0x8c(%rbp),%edi
imul   -0x14(%rbp),%edi
add    -0x90(%rbp),%edi
movslq %edi,%rdi
mov    (%rax,%rdi,4),%r8d
lea    0x955(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    -0x90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x90(%rbp)
jmp    1687 <main+0x517>
jmp    171a <main+0x5aa>
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    166e <main+0x4fe>
mov    0x28b3(%rip),%rax
mov    (%rax),%edi
lea    -0x48(%rbp),%rsi
call   1030 <clock_gettime@plt>
mov    -0x48(%rbp),%rax
sub    -0x38(%rbp),%rax
imul   $0x3b9aca00,%rax,%rax
cvtsi2sd %rax,%xmm0
addsd  -0x40(%rbp),%xmm0
subsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x20(%rbp)
movsd  -0x20(%rbp),%xmm0
movsd  0x890(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x24(%rbp),%xmm0
lea    0x8ec(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movl   $0x0,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
mov    -0x14(%rbp),%ecx
imul   -0x14(%rbp),%ecx
cmp    %ecx,%eax
jge    17d5 <main+0x665>
mov    -0x68(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    179a <main+0x62a>
mov    -0x14(%rbp),%esi
imul   -0x14(%rbp),%esi
mov    $0x4,%edi
call   1060 <calloc@plt>
mov    %rax,-0x70(%rbp)
movl   $0x0,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
mov    -0x14(%rbp),%ecx
imul   -0x14(%rbp),%ecx
cmp    %ecx,%eax
jge    182f <main+0x6bf>
mov    -0x70(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    17f4 <main+0x684>
mov    -0x14(%rbp),%esi
imul   -0x14(%rbp),%esi
mov    $0x4,%edi
call   1060 <calloc@plt>
mov    %rax,-0x78(%rbp)
movl   $0x0,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
mov    -0x14(%rbp),%ecx
imul   -0x14(%rbp),%ecx
cmp    %ecx,%eax
jge    1889 <main+0x719>
mov    -0x78(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    184e <main+0x6de>
mov    0x2758(%rip),%rax
mov    (%rax),%edi
lea    -0x38(%rbp),%rsi
call   1030 <clock_gettime@plt>
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1acf <main+0x95f>
movl   $0x0,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1ab6 <main+0x946>
mov    -0x50(%rbp),%rax
mov    -0x8c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x94(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x68(%rbp),%rax
mov    -0x8c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x94(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x8c(%rbp),%eax
imul   -0x14(%rbp),%eax
add    -0x94(%rbp),%eax
cltd
idivl  -0x14(%rbp)
cvtsi2ss %eax,%xmm0
mov    -0x94(%rbp),%esi
mov    -0x68(%rbp),%rax
mov    -0x8c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x94(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
lea    0x6d5(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movl   $0x0,-0x90(%rbp)
mov    -0x90(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1a9d <main+0x92d>
movsd  -0xa8(%rbp),%xmm0
ff
mov    -0x58(%rbp),%rax
mov    -0x94(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x90(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x60(%rbp),%rax
mov    -0x8c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x90(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%rax
mov    -0x8c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x90(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x70(%rbp),%rax
mov    -0x94(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x90(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x8c(%rbp),%eax
imul   -0x14(%rbp),%eax
add    -0x90(%rbp),%eax
cltd
idivl  -0x14(%rbp)
cvtsi2ss %eax,%xmm0
mov    -0x90(%rbp),%esi
mov    -0x78(%rbp),%rax
mov    -0x8c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x90(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
lea    0x5d4(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    -0x94(%rbp),%eax
imul   -0x14(%rbp),%eax
add    -0x90(%rbp),%eax
cltd
idivl  -0x14(%rbp)
cvtsi2ss %eax,%xmm0
mov    -0x90(%rbp),%esi
mov    -0x70(%rbp),%rax
mov    -0x94(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x90(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
lea    0x5b8(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    -0x90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x90(%rbp)
jmp    1961 <main+0x7f1>
jmp    1aa2 <main+0x932>
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    18be <main+0x74e>
jmp    1abb <main+0x94b>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    18a5 <main+0x735>
movl   $0x0,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1b99 <main+0xa29>
movl   $0x0,-0x90(%rbp)
mov    -0x90(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1b80 <main+0xa10>
cvtsi2ssl -0x8c(%rbp),%xmm0
ff
mov    -0x90(%rbp),%esi
mov    -0x78(%rbp),%rax
mov    -0x8c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x90(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x68(%rbp),%rax
mov    -0x8c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x90(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%ecx
mov    -0x70(%rbp),%rax
mov    -0x8c(%rbp),%edi
imul   -0x14(%rbp),%edi
add    -0x90(%rbp),%edi
movslq %edi,%rdi
mov    (%rax,%rdi,4),%r8d
lea    0x4ea(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    -0x90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x90(%rbp)
jmp    1af2 <main+0x982>
jmp    1b85 <main+0xa15>
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    1ad9 <main+0x969>
mov    0x2448(%rip),%rax
mov    (%rax),%edi
lea    -0x48(%rbp),%rsi
call   1030 <clock_gettime@plt>
mov    -0x48(%rbp),%rax
sub    -0x38(%rbp),%rax
imul   $0x3b9aca00,%rax,%rax
cvtsi2sd %rax,%xmm0
addsd  -0x40(%rbp),%xmm0
subsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x20(%rbp)
movsd  -0x20(%rbp),%xmm0
movsd  0x425(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x24(%rbp),%xmm0
lea    0x481(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
xor    %eax,%eax
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xb8,%rsp
mov    0x8(%rsi),%rdi
call   1090 <atoi@plt>
mov    %eax,%r12d
mov    %eax,%r14d
xor    %edi,%edi
call   1080 <time@plt>
mov    %eax,%edi
call   1060 <srand@plt>
imul   %r12d,%r12d
mov    $0x8,%edi
mov    %r12d,%esi
call   1070 <calloc@plt>
mov    %r12d,%ebp
test   %r12d,%r12d
mov    %rax,0x80(%rsp)
mov    %r12d,0x7c(%rsp)
mov    %rbp,0xa8(%rsp)
je     12e6 <main+0x166>
mov    %rax,%r13
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
xor    %eax,%eax
call   10a0 <rand@plt>
divsd  0xe01(%rip),%xmm0
movsd  %xmm0,0x0(%r13,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%rbp
jne    11f0 <main+0x70>
mov    $0x8,%edi
mov    %r12d,%esi
call   1070 <calloc@plt>
mov    %rax,%r15
test   %r12d,%r12d
je     12f6 <main+0x176>
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
xor    %eax,%eax
call   10a0 <rand@plt>
divsd  0xdc1(%rip),%xmm0
movsd  %xmm0,(%r15,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%rbp
jne    1230 <main+0xb0>
mov    $0x8,%edi
mov    %r12d,%esi
call   1070 <calloc@plt>
test   %r12d,%r12d
mov    %rax,0x60(%rsp)
je     1308 <main+0x188>
mov    %r15,0x20(%rsp)
lea    0x0(,%rbp,8),%rdx
mov    %rax,%rdi
xor    %esi,%esi
call   1050 <memset@plt>
mov    $0x4,%edi
mov    %r12d,%esi
call   1070 <calloc@plt>
mov    %rbp,%rcx
mov    %rax,%rbp
lea    0x0(,%rcx,4),%rbx
mov    %rax,%rdi
xor    %esi,%esi
mov    %rbx,%rdx
call   1050 <memset@plt>
mov    $0x4,%edi
mov    %r12d,%esi
call   1070 <calloc@plt>
mov    %rax,0x18(%rsp)
mov    %rax,%rdi
xor    %esi,%esi
mov    %rbx,%rdx
call   1050 <memset@plt>
mov    $0x4,%edi
mov    %r12d,%esi
call   1070 <calloc@plt>
mov    %rax,%rdi
xor    %esi,%esi
mov    %rbx,%rdx
mov    %rax,%rbx
call   1050 <memset@plt>
jmp    133f <main+0x1bf>
mov    $0x8,%edi
mov    %r12d,%esi
call   1070 <calloc@plt>
mov    %rax,%r15
mov    $0x8,%edi
mov    %r12d,%esi
call   1070 <calloc@plt>
mov    %rax,0x60(%rsp)
mov    %r15,0x20(%rsp)
mov    $0x4,%edi
mov    %r12d,%esi
call   1070 <calloc@plt>
mov    %rax,%rbp
mov    $0x4,%edi
mov    %r12d,%esi
call   1070 <calloc@plt>
mov    %rax,0x18(%rsp)
mov    $0x4,%edi
mov    %r12d,%esi
call   1070 <calloc@plt>
mov    %rax,%rbx
mov    0x2ca2(%rip),%rax
mov    (%rax),%edi
lea    0x98(%rsp),%rsi
call   1030 <clock_gettime@plt>
mov    %r14,0x48(%rsp)
test   %r14d,%r14d
mov    %rbp,0x30(%rsp)
jle    159e <main+0x41e>
mov    0x48(%rsp),%r14
lea    0x0(,%r14,8),%rax
mov    %rax,0xb0(%rsp)
lea    0x0(,%r14,4),%rax
mov    %rax,0x50(%rsp)
xor    %ecx,%ecx
mov    0x30(%rsp),%r12
mov    0x80(%rsp),%rdx
xor    %esi,%esi
mov    0x60(%rsp),%rdi
mov    %rbx,0x58(%rsp)
mov    0x18(%rsp),%rbp
nopw   0x0(%rax,%rax,1)
mov    %rdx,0x38(%rsp)
mov    %rcx,0x70(%rsp)
mov    %rsi,0x28(%rsp)
imul   %r14,%rsi
mov    %rsi,0x68(%rsp)
xor    %ecx,%ecx
mov    %rcx,0x10(%rsp)
nop
mov    0x68(%rsp),%rcx
mov    0x10(%rsp),%r15
lea    (%r15,%rcx,1),%rax
movsd  (%rdi,%rax,8),%xmm0
movsd  %xmm0,0x8(%rsp)
mov    (%rbx,%rax,4),%ecx
add    $0x1,%ecx
mov    %ecx,(%rbx,%rax,4)
mov    %rax,0x40(%rsp)
cltd
idiv   %r14d
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
lea    0xc07(%rip),%rdi
mov    %r15d,%esi
mov    %ecx,%edx
mov    $0x1,%al
call   1040 <printf@plt>
xor    %ebx,%ebx
mov    0x38(%rsp),%r13
nopl   0x0(%rax)
movsd  0x0(%r13,%rbx,8),%xmm0
mov    0x20(%rsp),%rax
mulsd  (%rax,%r15,8),%xmm0
addl   $0x1,(%r12,%rbx,4)
addl   $0x1,0x0(%rbp,%r15,4)
movsd  0x8(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
mov    0x70(%rsp),%rax
add    %ebx,%eax
cltd
idiv   %r14d
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
mov    (%r12,%rbx,4),%edx
lea    0xbbb(%rip),%rdi
mov    %ebx,%esi
mov    $0x1,%al
call   1040 <printf@plt>
mov    %r15d,%eax
cltd
idiv   %r14d
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
mov    0x0(%rbp,%r15,4),%edx
lea    0xbad(%rip),%rdi
mov    0x10(%rsp),%rsi
mov    $0x1,%al
call   1040 <printf@plt>
add    $0x1,%rbx
add    %r14,%r15
cmp    %rbx,%r14
jne    1420 <main+0x2a0>
mov    0x60(%rsp),%rdi
mov    0x40(%rsp),%rax
movsd  0x8(%rsp),%xmm0
movsd  %xmm0,(%rdi,%rax,8)
mov    0x10(%rsp),%rdx
add    $0x1,%rdx
mov    %rdx,%rcx
mov    %rdx,0x10(%rsp)
cmp    %r14,%rdx
mov    0x58(%rsp),%rbx
jne    13d0 <main+0x250>
mov    0x28(%rsp),%rsi
add    $0x1,%rsi
mov    0x70(%rsp),%rcx
add    %r14,%rcx
mov    0x38(%rsp),%rdx
add    0xb0(%rsp),%rdx
add    0x50(%rsp),%r12
cmp    %r14,%rsi
jne    13b0 <main+0x230>
test   %r14d,%r14d
mov    0x18(%rsp),%rax
jle    159e <main+0x41e>
xor    %edx,%edx
lea    0xb2f(%rip),%r12
mov    0x30(%rsp),%r14
mov    0x48(%rsp),%r13
nopw   0x0(%rax,%rax,1)
mov    %rdx,0x10(%rsp)
xorps  %xmm0,%xmm0
cvtsi2ss %edx,%xmm0
movss  %xmm0,0x8(%rsp)
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%rbx,%rbp,4),%edx
mov    (%r14,%rbp,4),%ecx
mov    (%rax,%rbp,4),%r8d
mov    %r12,%rdi
movss  0x8(%rsp),%xmm0
mov    %ebp,%esi
mov    %rbx,%r15
mov    %rax,%rbx
mov    $0x1,%al
call   1040 <printf@plt>
mov    %rbx,%rax
mov    %r15,%rbx
add    $0x1,%rbp
cmp    %rbp,%r13
jne    1550 <main+0x3d0>
mov    0x10(%rsp),%rdx
add    $0x1,%rdx
mov    0x50(%rsp),%rcx
add    %rcx,%rbx
add    %rcx,%r14
add    %rcx,%rax
cmp    %r13,%rdx
jne    1530 <main+0x3b0>
mov    0x2a43(%rip),%rax
mov    (%rax),%edi
lea    0x88(%rsp),%rsi
call   1030 <clock_gettime@plt>
mov    0x88(%rsp),%rax
sub    0x98(%rsp),%rax
imul   $0x3b9aca00,%rax,%rax
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
addsd  0x90(%rsp),%xmm0
subsd  0xa0(%rsp),%xmm0
divsd  0xa1b(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0xa7d(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    0x7c(%rsp),%ebx
test   %ebx,%ebx
je     165e <main+0x4de>
mov    0xa8(%rsp),%rbp
shl    $0x2,%rbp
mov    0x30(%rsp),%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1050 <memset@plt>
mov    $0x4,%edi
mov    %ebx,%esi
call   1070 <calloc@plt>
mov    %rax,%r15
mov    %rax,%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1050 <memset@plt>
mov    $0x4,%edi
mov    %ebx,%esi
call   1070 <calloc@plt>
mov    %rax,0x28(%rsp)
mov    %rax,%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1050 <memset@plt>
jmp    167e <main+0x4fe>
mov    $0x4,%edi
mov    %ebx,%esi
call   1070 <calloc@plt>
mov    %rax,%r15
mov    $0x4,%edi
mov    %ebx,%esi
call   1070 <calloc@plt>
mov    %rax,0x28(%rsp)
mov    0x48(%rsp),%r14
mov    0x295e(%rip),%rax
mov    (%rax),%edi
lea    0x98(%rsp),%rsi
call   1030 <clock_gettime@plt>
test   %r14d,%r14d
mov    0x28(%rsp),%rax
jle    18c9 <main+0x749>
lea    0x0(,%r14,8),%rcx
mov    %rcx,0x58(%rsp)
lea    0x0(,%r14,4),%rcx
mov    %rcx,0x18(%rsp)
xor    %ecx,%ecx
mov    %r15,0x50(%rsp)
xor    %edx,%edx
mov    %rdx,0x40(%rsp)
nop
mov    %r15,0x68(%rsp)
mov    %rcx,0x38(%rsp)
mov    %rax,%r13
mov    0x60(%rsp),%rbp
xor    %eax,%eax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
mov    %rax,0x8(%rsp)
mov    %rcx,0x70(%rsp)
mov    %rcx,%rax
imul   %r14,%rax
mov    0x40(%rsp),%rsi
add    %rsi,%rax
mov    0x80(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,0x10(%rsp)
mov    0x30(%rsp),%rdx
mov    (%rdx,%rax,4),%ecx
add    $0x1,%ecx
mov    %ecx,(%rdx,%rax,4)
cltd
idiv   %r14d
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
lea    0x8e9(%rip),%rdi
mov    %ecx,%edx
mov    $0x1,%al
call   1040 <printf@plt>
xor    %ebx,%ebx
mov    0x38(%rsp),%r15
mov    0x68(%rsp),%r12
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x20(%rsp),%rax
movsd  (%rax,%rbx,8),%xmm0
mulsd  0x10(%rsp),%xmm0
addsd  0x0(%rbp,%rbx,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rbx,8)
addl   $0x1,0x0(%r13,%rbx,4)
addl   $0x1,(%r12,%rbx,4)
mov    0x8(%rsp),%rax
add    %ebx,%eax
cltd
idiv   %r14d
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
mov    0x0(%r13,%rbx,4),%edx
lea    0x86b(%rip),%rdi
mov    %ebx,%esi
mov    $0x1,%al
call   1040 <printf@plt>
lea    (%r15,%rbx,1),%eax
cltd
idiv   %r14d
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
mov    (%r12,%rbx,4),%edx
lea    0x872(%rip),%rdi
mov    %ebx,%esi
mov    $0x1,%al
call   1040 <printf@plt>
add    $0x1,%rbx
cmp    %rbx,%r14
jne    1760 <main+0x5e0>
mov    0x70(%rsp),%rcx
add    $0x1,%rcx
mov    0x8(%rsp),%rax
add    %r14,%rax
add    0x58(%rsp),%rbp
add    0x18(%rsp),%r13
cmp    %r14,%rcx
jne    16f0 <main+0x570>
mov    0x40(%rsp),%rdx
add    $0x1,%rdx
mov    0x38(%rsp),%rcx
add    %r14,%rcx
mov    0x58(%rsp),%rax
add    %rax,0x20(%rsp)
mov    0x68(%rsp),%r15
add    0x18(%rsp),%r15
mov    %rdx,%rax
mov    %rdx,0x40(%rsp)
cmp    %r14,%rdx
mov    0x28(%rsp),%rax
jne    16d0 <main+0x550>
test   %r14d,%r14d
mov    0x30(%rsp),%r13
mov    0x50(%rsp),%rbx
jle    18c9 <main+0x749>
xor    %edx,%edx
lea    0x7fa(%rip),%r12
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rdx,0x20(%rsp)
xorps  %xmm0,%xmm0
cvtsi2ss %edx,%xmm0
movss  %xmm0,0x8(%rsp)
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%rax,%rbp,4),%edx
mov    0x0(%r13,%rbp,4),%ecx
mov    (%rbx,%rbp,4),%r8d
mov    %r12,%rdi
movss  0x8(%rsp),%xmm0
mov    %ebp,%esi
mov    %rax,%r15
mov    $0x1,%al
call   1040 <printf@plt>
mov    %r15,%rax
add    $0x1,%rbp
cmp    %rbp,%r14
jne    1880 <main+0x700>
mov    0x20(%rsp),%rdx
add    $0x1,%rdx
mov    0x18(%rsp),%rcx
add    %rcx,%rax
add    %rcx,%r13
add    %rcx,%rbx
cmp    %r14,%rdx
jne    1860 <main+0x6e0>
mov    0x2718(%rip),%rax
mov    (%rax),%edi
lea    0x88(%rsp),%rsi
call   1030 <clock_gettime@plt>
mov    0x88(%rsp),%rax
sub    0x98(%rsp),%rax
imul   $0x3b9aca00,%rax,%rax
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
addsd  0x90(%rsp),%xmm0
subsd  0xa0(%rsp),%xmm0
divsd  0x6f0(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x752(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
xor    %eax,%eax
add    $0xb8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
%struct.timespec = type { i64, double }
@CLOCK_MONOTONIC = global i32 0
@.str = [21 x i8] c"Reading C[%d,%d] %d\0A\00"
@.str.1 = [21 x i8] c"Reading A[%d,%d] %d\0A\00"
@.str.2 = [21 x i8] c"Reading B[%d,%d] %d\0A\00"
@.str.3 = [38 x i8] c"Pos (%d,%d) -> C: %d \09 A: %d \09 B: %d\0A\00"
@.str.4 = [4 x i8] c"%f\0A\00"
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8**
%6 = alloca i32
%7 = alloca double
%8 = alloca float
%9 = alloca %struct.timespec
%10 = alloca %struct.timespec
%11 = alloca double*
%12 = alloca double*
%13 = alloca double*
%14 = alloca i32*
%15 = alloca i32*
%16 = alloca i32*
%17 = alloca double
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca double
%24 = alloca double
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
%25 = load i8**, i8*** %5
%26 = getelementptr inbounds i8*, i8** %25, i64 1
%27 = load i8*, i8** %26
%28 = call i32 @atoi(i8* %27)
store i32 %28, i32* %6
store i32 4, i32* %18
store i32 4, i32* %19
%29 = call i32 @time(i32* null)
%30 = call i32 @srand(i32 %29)
%31 = load i32, i32* %6
%32 = load i32, i32* %6
%33 = mul nsw i32 %31, %32
%34 = call i64 @calloc(i32 8, i32 %33)
%35 = inttoptr i64 %34 to double*
store double* %35, double** %11
store i32 0, i32* %20
br label %36
36: ; preds = %49, %2
%37 = load i32, i32* %20
%38 = load i32, i32* %6
%39 = load i32, i32* %6
%40 = mul nsw i32 %38, %39
%41 = icmp slt i32 %37, %40
br i1 %41, label %42, label %52
42: ; preds = %36
%43 = call double (...) @rand()
%44 = fdiv double %43, 1.000000e+06
%45 = load double*, double** %11
%46 = load i32, i32* %20
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds double, double* %45, i64 %47
store double %44, double* %48
br label %49
49: ; preds = %42
%50 = load i32, i32* %20
%51 = add nsw i32 %50, 1
store i32 %51, i32* %20
br label %36
52: ; preds = %36
%53 = load i32, i32* %6
%54 = load i32, i32* %6
%55 = mul nsw i32 %53, %54
%56 = call i64 @calloc(i32 8, i32 %55)
%57 = inttoptr i64 %56 to double*
store double* %57, double** %12
store i32 0, i32* %20
br label %58
58: ; preds = %71, %52
%59 = load i32, i32* %20
%60 = load i32, i32* %6
%61 = load i32, i32* %6
%62 = mul nsw i32 %60, %61
%63 = icmp slt i32 %59, %62
br i1 %63, label %64, label %74
64: ; preds = %58
%65 = call double (...) @rand()
%66 = fdiv double %65, 1.000000e+06
%67 = load double*, double** %12
%68 = load i32, i32* %20
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds double, double* %67, i64 %69
store double %66, double* %70
br label %71
71: ; preds = %64
%72 = load i32, i32* %20
%73 = add nsw i32 %72, 1
store i32 %73, i32* %20
br label %58
74: ; preds = %58
%75 = load i32, i32* %6
%76 = load i32, i32* %6
%77 = mul nsw i32 %75, %76
%78 = call i64 @calloc(i32 8, i32 %77)
%79 = inttoptr i64 %78 to double*
store double* %79, double** %13
store i32 0, i32* %20
br label %80
80: ; preds = %91, %74
%81 = load i32, i32* %20
%82 = load i32, i32* %6
%83 = load i32, i32* %6
%84 = mul nsw i32 %82, %83
%85 = icmp slt i32 %81, %84
br i1 %85, label %86, label %94
86: ; preds = %80
%87 = load double*, double** %13
%88 = load i32, i32* %20
%89 = sext i32 %88 to i64
%90 = getelementptr inbounds double, double* %87, i64 %89
store double 0.000000e+00, double* %90
br label %91
91: ; preds = %86
%92 = load i32, i32* %20
%93 = add nsw i32 %92, 1
store i32 %93, i32* %20
br label %80
94: ; preds = %80
%95 = load i32, i32* %6
%96 = load i32, i32* %6
%97 = mul nsw i32 %95, %96
%98 = call i64 @calloc(i32 4, i32 %97)
%99 = inttoptr i64 %98 to i32*
store i32* %99, i32** %14
store i32 0, i32* %20
br label %100
100: ; preds = %111, %94
%101 = load i32, i32* %20
%102 = load i32, i32* %6
%103 = load i32, i32* %6
%104 = mul nsw i32 %102, %103
%105 = icmp slt i32 %101, %104
br i1 %105, label %106, label %114
106: ; preds = %100
%107 = load i32*, i32** %14
%108 = load i32, i32* %20
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds i32, i32* %107, i64 %109
store i32 0, i32* %110
br label %111
111: ; preds = %106
%112 = load i32, i32* %20
%113 = add nsw i32 %112, 1
store i32 %113, i32* %20
br label %100
114: ; preds = %100
%115 = load i32, i32* %6
%116 = load i32, i32* %6
%117 = mul nsw i32 %115, %116
%118 = call i64 @calloc(i32 4, i32 %117)
%119 = inttoptr i64 %118 to i32*
store i32* %119, i32** %15
store i32 0, i32* %20
br label %120
120: ; preds = %131, %114
%121 = load i32, i32* %20
%122 = load i32, i32* %6
%123 = load i32, i32* %6
%124 = mul nsw i32 %122, %123
%125 = icmp slt i32 %121, %124
br i1 %125, label %126, label %134
126: ; preds = %120
%127 = load i32*, i32** %15
%128 = load i32, i32* %20
%129 = sext i32 %128 to i64
%130 = getelementptr inbounds i32, i32* %127, i64 %129
store i32 0, i32* %130
br label %131
131: ; preds = %126
%132 = load i32, i32* %20
%133 = add nsw i32 %132, 1
store i32 %133, i32* %20
br label %120
134: ; preds = %120
%135 = load i32, i32* %6
%136 = load i32, i32* %6
%137 = mul nsw i32 %135, %136
%138 = call i64 @calloc(i32 4, i32 %137)
%139 = inttoptr i64 %138 to i32*
store i32* %139, i32** %16
store i32 0, i32* %20
br label %140
140: ; preds = %151, %134
%141 = load i32, i32* %20
%142 = load i32, i32* %6
%143 = load i32, i32* %6
%144 = mul nsw i32 %142, %143
%145 = icmp slt i32 %141, %144
br i1 %145, label %146, label %154
146: ; preds = %140
%147 = load i32*, i32** %16
%148 = load i32, i32* %20
%149 = sext i32 %148 to i64
%150 = getelementptr inbounds i32, i32* %147, i64 %149
store i32 0, i32* %150
br label %151
151: ; preds = %146
%152 = load i32, i32* %20
%153 = add nsw i32 %152, 1
store i32 %153, i32* %20
br label %140
154: ; preds = %140
%155 = load i32, i32* @CLOCK_MONOTONIC
%156 = call i32 @clock_gettime(i32 %155, %struct.timespec* %9)
store i32 0, i32* %20
br label %157
157: ; preds = %305, %154
%158 = load i32, i32* %20
%159 = load i32, i32* %6
%160 = icmp slt i32 %158, %159
br i1 %160, label %161, label %308
161: ; preds = %157
store i32 0, i32* %21
br label %162
162: ; preds = %301, %161
%163 = load i32, i32* %21
%164 = load i32, i32* %6
%165 = icmp slt i32 %163, %164
br i1 %165, label %166, label %304
166: ; preds = %162
%167 = load double*, double** %13
%168 = load i32, i32* %20
%169 = load i32, i32* %6
%170 = mul nsw i32 %168, %169
%171 = load i32, i32* %21
%172 = add nsw i32 %170, %171
%173 = sext i32 %172 to i64
%174 = getelementptr inbounds double, double* %167, i64 %173
%175 = load double, double* %174
store double %175, double* %23
%176 = load i32*, i32** %16
%177 = load i32, i32* %20
%178 = load i32, i32* %6
%179 = mul nsw i32 %177, %178
%180 = load i32, i32* %21
%181 = add nsw i32 %179, %180
%182 = sext i32 %181 to i64
%183 = getelementptr inbounds i32, i32* %176, i64 %182
%184 = load i32, i32* %183
%185 = add nsw i32 %184, 1
store i32 %185, i32* %183
%186 = load i32, i32* %20
%187 = load i32, i32* %6
%188 = mul nsw i32 %186, %187
%189 = load i32, i32* %21
%190 = add nsw i32 %188, %189
%191 = load i32, i32* %6
%192 = sdiv i32 %190, %191
%193 = sitofp i32 %192 to float
%194 = load i32, i32* %21
%195 = load i32*, i32** %16
%196 = load i32, i32* %20
%197 = load i32, i32* %6
%198 = mul nsw i32 %196, %197
%199 = load i32, i32* %21
%200 = add nsw i32 %198, %199
%201 = sext i32 %200 to i64
%202 = getelementptr inbounds i32, i32* %195, i64 %201
%203 = load i32, i32* %202
%204 = call i32 (i8*, float, ...) @printf(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str, i64 0, i64 0), float %193, i32 %194, i32 %203)
store i32 0, i32* %22
br label %205
205: ; preds = %288, %166
%206 = load i32, i32* %22
%207 = load i32, i32* %6
%208 = icmp slt i32 %206, %207
br i1 %208, label %209, label %291
209: ; preds = %205
%210 = load double*, double** %11
%211 = load i32, i32* %20
%212 = load i32, i32* %6
%213 = mul nsw i32 %211, %212
%214 = load i32, i32* %22
%215 = add nsw i32 %213, %214
%216 = sext i32 %215 to i64
%217 = getelementptr inbounds double, double* %210, i64 %216
%218 = load double, double* %217
%219 = load double*, double** %12
%220 = load i32, i32* %22
%221 = load i32, i32* %6
%222 = mul nsw i32 %220, %221
%223 = load i32, i32* %21
%224 = add nsw i32 %222, %223
%225 = sext i32 %224 to i64
%226 = getelementptr inbounds double, double* %219, i64 %225
%227 = load double, double* %226
%228 = load double, double* %23
%229 = call double @llvm.fmuladd.f64(double %218, double %227, double %228)
store double %229, double* %23
%230 = load i32*, i32** %14
%231 = load i32, i32* %20
%232 = load i32, i32* %6
%233 = mul nsw i32 %231, %232
%234 = load i32, i32* %22
%235 = add nsw i32 %233, %234
%236 = sext i32 %235 to i64
%237 = getelementptr inbounds i32, i32* %230, i64 %236
%238 = load i32, i32* %237
%239 = add nsw i32 %238, 1
store i32 %239, i32* %237
%240 = load i32*, i32** %15
%241 = load i32, i32* %22
%242 = load i32, i32* %6
%243 = mul nsw i32 %241, %242
%244 = load i32, i32* %21
%245 = add nsw i32 %243, %244
%246 = sext i32 %245 to i64
%247 = getelementptr inbounds i32, i32* %240, i64 %246
%248 = load i32, i32* %247
%249 = add nsw i32 %248, 1
store i32 %249, i32* %247
%250 = load i32, i32* %20
%251 = load i32, i32* %6
%252 = mul nsw i32 %250, %251
%253 = load i32, i32* %22
%254 = add nsw i32 %252, %253
%255 = load i32, i32* %6
%256 = sdiv i32 %254, %255
%257 = sitofp i32 %256 to float
%258 = load i32, i32* %22
%259 = load i32*, i32** %14
%260 = load i32, i32* %20
%261 = load i32, i32* %6
%262 = mul nsw i32 %260, %261
%263 = load i32, i32* %22
%264 = add nsw i32 %262, %263
%265 = sext i32 %264 to i64
%266 = getelementptr inbounds i32, i32* %259, i64 %265
%267 = load i32, i32* %266
%268 = call i32 (i8*, float, ...) @printf(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.1, i64 0, i64 0), float %257, i32 %258, i32 %267)
%269 = load i32, i32* %22
%270 = load i32, i32* %6
%271 = mul nsw i32 %269, %270
%272 = load i32, i32* %21
%273 = add nsw i32 %271, %272
%274 = load i32, i32* %6
%275 = sdiv i32 %273, %274
%276 = sitofp i32 %275 to float
%277 = load i32, i32* %21
%278 = load i32*, i32** %15
%279 = load i32, i32* %22
%280 = load i32, i32* %6
%281 = mul nsw i32 %279, %280
%282 = load i32, i32* %21
%283 = add nsw i32 %281, %282
%284 = sext i32 %283 to i64
%285 = getelementptr inbounds i32, i32* %278, i64 %284
%286 = load i32, i32* %285
%287 = call i32 (i8*, float, ...) @printf(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.2, i64 0, i64 0), float %276, i32 %277, i32 %286)
br label %288
288: ; preds = %209
%289 = load i32, i32* %22
%290 = add nsw i32 %289, 1
store i32 %290, i32* %22
br label %205
291: ; preds = %205
%292 = load double, double* %23
%293 = load double*, double** %13
%294 = load i32, i32* %20
%295 = load i32, i32* %6
%296 = mul nsw i32 %294, %295
%297 = load i32, i32* %21
%298 = add nsw i32 %296, %297
%299 = sext i32 %298 to i64
%300 = getelementptr inbounds double, double* %293, i64 %299
store double %292, double* %300
br label %301
301: ; preds = %291
%302 = load i32, i32* %21
%303 = add nsw i32 %302, 1
store i32 %303, i32* %21
br label %162
304: ; preds = %162
br label %305
305: ; preds = %304
%306 = load i32, i32* %20
%307 = add nsw i32 %306, 1
store i32 %307, i32* %20
br label %157
308: ; preds = %157
store i32 0, i32* %20
br label %309
309: ; preds = %354, %308
%310 = load i32, i32* %20
%311 = load i32, i32* %6
%312 = icmp slt i32 %310, %311
br i1 %312, label %313, label %357
313: ; preds = %309
store i32 0, i32* %21
br label %314
314: ; preds = %350, %313
%315 = load i32, i32* %21
%316 = load i32, i32* %6
%317 = icmp slt i32 %315, %316
br i1 %317, label %318, label %353
318: ; preds = %314
%319 = load i32, i32* %20
%320 = sitofp i32 %319 to float
%321 = load i32, i32* %21
%322 = load i32*, i32** %16
%323 = load i32, i32* %20
%324 = load i32, i32* %6
%325 = mul nsw i32 %323, %324
%326 = load i32, i32* %21
%327 = add nsw i32 %325, %326
%328 = sext i32 %327 to i64
%329 = getelementptr inbounds i32, i32* %322, i64 %328
%330 = load i32, i32* %329
%331 = load i32*, i32** %14
%332 = load i32, i32* %20
%333 = load i32, i32* %6
%334 = mul nsw i32 %332, %333
%335 = load i32, i32* %21
%336 = add nsw i32 %334, %335
%337 = sext i32 %336 to i64
%338 = getelementptr inbounds i32, i32* %331, i64 %337
%339 = load i32, i32* %338
%340 = load i32*, i32** %15
%341 = load i32, i32* %20
%342 = load i32, i32* %6
%343 = mul nsw i32 %341, %342
%344 = load i32, i32* %21
%345 = add nsw i32 %343, %344
%346 = sext i32 %345 to i64
%347 = getelementptr inbounds i32, i32* %340, i64 %346
%348 = load i32, i32* %347
%349 = call i32 (i8*, float, ...) @printf(i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.3, i64 0, i64 0), float %320, i32 %321, i32 %330, i32 %339, i32 %348)
br label %350
350: ; preds = %318
%351 = load i32, i32* %21
%352 = add nsw i32 %351, 1
store i32 %352, i32* %21
br label %314
353: ; preds = %314
br label %354
354: ; preds = %353
%355 = load i32, i32* %20
%356 = add nsw i32 %355, 1
store i32 %356, i32* %20
br label %309
357: ; preds = %309
%358 = load i32, i32* @CLOCK_MONOTONIC
%359 = call i32 @clock_gettime(i32 %358, %struct.timespec* %10)
%360 = getelementptr inbounds %struct.timespec, %struct.timespec* %10, i32 0, i32 0
%361 = load i64, i64* %360
%362 = getelementptr inbounds %struct.timespec, %struct.timespec* %9, i32 0, i32 0
%363 = load i64, i64* %362
%364 = sub nsw i64 %361, %363
%365 = mul nsw i64 1000000000, %364
%366 = sitofp i64 %365 to double
%367 = getelementptr inbounds %struct.timespec, %struct.timespec* %10, i32 0, i32 1
%368 = load double, double* %367
%369 = fadd double %366, %368
%370 = getelementptr inbounds %struct.timespec, %struct.timespec* %9, i32 0, i32 1
%371 = load double, double* %370
%372 = fsub double %369, %371
store double %372, double* %7
%373 = load double, double* %7
%374 = fdiv double %373, 1.000000e+09
%375 = fptrunc double %374 to float
store float %375, float* %8
%376 = load float, float* %8
%377 = call i32 (i8*, float, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i64 0, i64 0), float %376)
store i32 0, i32* %20
br label %378
378: ; preds = %389, %357
%379 = load i32, i32* %20
%380 = load i32, i32* %6
%381 = load i32, i32* %6
%382 = mul nsw i32 %380, %381
%383 = icmp slt i32 %379, %382
br i1 %383, label %384, label %392
384: ; preds = %378
%385 = load i32*, i32** %14
%386 = load i32, i32* %20
%387 = sext i32 %386 to i64
%388 = getelementptr inbounds i32, i32* %385, i64 %387
store i32 0, i32* %388
br label %389
389: ; preds = %384
%390 = load i32, i32* %20
%391 = add nsw i32 %390, 1
store i32 %391, i32* %20
br label %378
392: ; preds = %378
%393 = load i32, i32* %6
%394 = load i32, i32* %6
%395 = mul nsw i32 %393, %394
%396 = call i64 @calloc(i32 4, i32 %395)
%397 = inttoptr i64 %396 to i32*
store i32* %397, i32** %15
store i32 0, i32* %20
br label %398
398: ; preds = %409, %392
%399 = load i32, i32* %20
%400 = load i32, i32* %6
%401 = load i32, i32* %6
%402 = mul nsw i32 %400, %401
%403 = icmp slt i32 %399, %402
br i1 %403, label %404, label %412
404: ; preds = %398
%405 = load i32*, i32** %15
%406 = load i32, i32* %20
%407 = sext i32 %406 to i64
%408 = getelementptr inbounds i32, i32* %405, i64 %407
store i32 0, i32* %408
br label %409
409: ; preds = %404
%410 = load i32, i32* %20
%411 = add nsw i32 %410, 1
store i32 %411, i32* %20
br label %398
412: ; preds = %398
%413 = load i32, i32* %6
%414 = load i32, i32* %6
%415 = mul nsw i32 %413, %414
%416 = call i64 @calloc(i32 4, i32 %415)
%417 = inttoptr i64 %416 to i32*
store i32* %417, i32** %16
store i32 0, i32* %20
br label %418
418: ; preds = %429, %412
%419 = load i32, i32* %20
%420 = load i32, i32* %6
%421 = load i32, i32* %6
%422 = mul nsw i32 %420, %421
%423 = icmp slt i32 %419, %422
br i1 %423, label %424, label %432
424: ; preds = %418
%425 = load i32*, i32** %16
%426 = load i32, i32* %20
%427 = sext i32 %426 to i64
%428 = getelementptr inbounds i32, i32* %425, i64 %427
store i32 0, i32* %428
br label %429
429: ; preds = %424
%430 = load i32, i32* %20
%431 = add nsw i32 %430, 1
store i32 %431, i32* %20
br label %418
432: ; preds = %418
%433 = load i32, i32* @CLOCK_MONOTONIC
%434 = call i32 @clock_gettime(i32 %433, %struct.timespec* %9)
store i32 0, i32* %22
br label %435
435: ; preds = %574, %432
%436 = load i32, i32* %22
%437 = load i32, i32* %6
%438 = icmp slt i32 %436, %437
br i1 %438, label %439, label %577
439: ; preds = %435
store i32 0, i32* %20
br label %440
440: ; preds = %570, %439
%441 = load i32, i32* %20
%442 = load i32, i32* %6
%443 = icmp slt i32 %441, %442
br i1 %443, label %444, label %573
444: ; preds = %440
%445 = load double*, double** %11
%446 = load i32, i32* %20
%447 = load i32, i32* %6
%448 = mul nsw i32 %446, %447
%449 = load i32, i32* %22
%450 = add nsw i32 %448, %449
%451 = sext i32 %450 to i64
%452 = getelementptr inbounds double, double* %445, i64 %451
%453 = load double, double* %452
store double %453, double* %24
%454 = load i32*, i32** %14
%455 = load i32, i32* %20
%456 = load i32, i32* %6
%457 = mul nsw i32 %455, %456
%458 = load i32, i32* %22
%459 = add nsw i32 %457, %458
%460 = sext i32 %459 to i64
%461 = getelementptr inbounds i32, i32* %454, i64 %460
%462 = load i32, i32* %461
%463 = add nsw i32 %462, 1
store i32 %463, i32* %461
%464 = load i32, i32* %20
%465 = load i32, i32* %6
%466 = mul nsw i32 %464, %465
%467 = load i32, i32* %22
%468 = add nsw i32 %466, %467
%469 = load i32, i32* %6
%470 = sdiv i32 %468, %469
%471 = sitofp i32 %470 to float
%472 = load i32, i32* %22
%473 = load i32*, i32** %14
%474 = load i32, i32* %20
%475 = load i32, i32* %6
%476 = mul nsw i32 %474, %475
%477 = load i32, i32* %22
%478 = add nsw i32 %476, %477
%479 = sext i32 %478 to i64
%480 = getelementptr inbounds i32, i32* %473, i64 %479
%481 = load i32, i32* %480
%482 = call i32 (i8*, float, ...) @printf(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.1, i64 0, i64 0), float %471, i32 %472, i32 %481)
store i32 0, i32* %21
br label %483
483: ; preds = %566, %444
%484 = load i32, i32* %21
%485 = load i32, i32* %6
%486 = icmp slt i32 %484, %485
br i1 %486, label %487, label %569
487: ; preds = %483
%488 = load double, double* %24
%489 = load double*, double** %12
%490 = load i32, i32* %22
%491 = load i32, i32* %6
%492 = mul nsw i32 %490, %491
%493 = load i32, i32* %21
%494 = add nsw i32 %492, %493
%495 = sext i32 %494 to i64
%496 = getelementptr inbounds double, double* %489, i64 %495
%497 = load double, double* %496
%498 = load double*, double** %13
%499 = load i32, i32* %20
%500 = load i32, i32* %6
%501 = mul nsw i32 %499, %500
%502 = load i32, i32* %21
%503 = add nsw i32 %501, %502
%504 = sext i32 %503 to i64
%505 = getelementptr inbounds double, double* %498, i64 %504
%506 = load double, double* %505
%507 = call double @llvm.fmuladd.f64(double %488, double %497, double %506)
store double %507, double* %505
%508 = load i32*, i32** %16
%509 = load i32, i32* %20
%510 = load i32, i32* %6
%511 = mul nsw i32 %509, %510
%512 = load i32, i32* %21
%513 = add nsw i32 %511, %512
%514 = sext i32 %513 to i64
%515 = getelementptr inbounds i32, i32* %508, i64 %514
%516 = load i32, i32* %515
%517 = add nsw i32 %516, 1
store i32 %517, i32* %515
%518 = load i32*, i32** %15
%519 = load i32, i32* %22
%520 = load i32, i32* %6
%521 = mul nsw i32 %519, %520
%522 = load i32, i32* %21
%523 = add nsw i32 %521, %522
%524 = sext i32 %523 to i64
%525 = getelementptr inbounds i32, i32* %518, i64 %524
%526 = load i32, i32* %525
%527 = add nsw i32 %526, 1
store i32 %527, i32* %525
%528 = load i32, i32* %20
%529 = load i32, i32* %6
%530 = mul nsw i32 %528, %529
%531 = load i32, i32* %21
%532 = add nsw i32 %530, %531
%533 = load i32, i32* %6
%534 = sdiv i32 %532, %533
%535 = sitofp i32 %534 to float
%536 = load i32, i32* %21
%537 = load i32*, i32** %16
%538 = load i32, i32* %20
%539 = load i32, i32* %6
%540 = mul nsw i32 %538, %539
%541 = load i32, i32* %21
%542 = add nsw i32 %540, %541
%543 = sext i32 %542 to i64
%544 = getelementptr inbounds i32, i32* %537, i64 %543
%545 = load i32, i32* %544
%546 = call i32 (i8*, float, ...) @printf(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str, i64 0, i64 0), float %535, i32 %536, i32 %545)
%547 = load i32, i32* %22
%548 = load i32, i32* %6
%549 = mul nsw i32 %547, %548
%550 = load i32, i32* %21
%551 = add nsw i32 %549, %550
%552 = load i32, i32* %6
%553 = sdiv i32 %551, %552
%554 = sitofp i32 %553 to float
%555 = load i32, i32* %21
%556 = load i32*, i32** %15
%557 = load i32, i32* %22
%558 = load i32, i32* %6
%559 = mul nsw i32 %557, %558
%560 = load i32, i32* %21
%561 = add nsw i32 %559, %560
%562 = sext i32 %561 to i64
%563 = getelementptr inbounds i32, i32* %556, i64 %562
%564 = load i32, i32* %563
%565 = call i32 (i8*, float, ...) @printf(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.2, i64 0, i64 0), float %554, i32 %555, i32 %564)
br label %566
566: ; preds = %487
%567 = load i32, i32* %21
%568 = add nsw i32 %567, 1
store i32 %568, i32* %21
br label %483
569: ; preds = %483
br label %570
570: ; preds = %569
%571 = load i32, i32* %20
%572 = add nsw i32 %571, 1
store i32 %572, i32* %20
br label %440
573: ; preds = %440
br label %574
574: ; preds = %573
%575 = load i32, i32* %22
%576 = add nsw i32 %575, 1
store i32 %576, i32* %22
br label %435
577: ; preds = %435
store i32 0, i32* %20
br label %578
578: ; preds = %623, %577
%579 = load i32, i32* %20
%580 = load i32, i32* %6
%581 = icmp slt i32 %579, %580
br i1 %581, label %582, label %626
582: ; preds = %578
store i32 0, i32* %21
br label %583
583: ; preds = %619, %582
%584 = load i32, i32* %21
%585 = load i32, i32* %6
%586 = icmp slt i32 %584, %585
br i1 %586, label %587, label %622
587: ; preds = %583
%588 = load i32, i32* %20
%589 = sitofp i32 %588 to float
%590 = load i32, i32* %21
%591 = load i32*, i32** %16
%592 = load i32, i32* %20
%593 = load i32, i32* %6
%594 = mul nsw i32 %592, %593
%595 = load i32, i32* %21
%596 = add nsw i32 %594, %595
%597 = sext i32 %596 to i64
%598 = getelementptr inbounds i32, i32* %591, i64 %597
%599 = load i32, i32* %598
%600 = load i32*, i32** %14
%601 = load i32, i32* %20
%602 = load i32, i32* %6
%603 = mul nsw i32 %601, %602
%604 = load i32, i32* %21
%605 = add nsw i32 %603, %604
%606 = sext i32 %605 to i64
%607 = getelementptr inbounds i32, i32* %600, i64 %606
%608 = load i32, i32* %607
%609 = load i32*, i32** %15
%610 = load i32, i32* %20
%611 = load i32, i32* %6
%612 = mul nsw i32 %610, %611
%613 = load i32, i32* %21
%614 = add nsw i32 %612, %613
%615 = sext i32 %614 to i64
%616 = getelementptr inbounds i32, i32* %609, i64 %615
%617 = load i32, i32* %616
%618 = call i32 (i8*, float, ...) @printf(i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.3, i64 0, i64 0), float %589, i32 %590, i32 %599, i32 %608, i32 %617)
br label %619
619: ; preds = %587
%620 = load i32, i32* %21
%621 = add nsw i32 %620, 1
store i32 %621, i32* %21
br label %583
622: ; preds = %583
br label %623
623: ; preds = %622
%624 = load i32, i32* %20
%625 = add nsw i32 %624, 1
store i32 %625, i32* %20
br label %578
626: ; preds = %578
%627 = load i32, i32* @CLOCK_MONOTONIC
%628 = call i32 @clock_gettime(i32 %627, %struct.timespec* %10)
%629 = getelementptr inbounds %struct.timespec, %struct.timespec* %10, i32 0, i32 0
%630 = load i64, i64* %629
%631 = getelementptr inbounds %struct.timespec, %struct.timespec* %9, i32 0, i32 0
%632 = load i64, i64* %631
%633 = sub nsw i64 %630, %632
%634 = mul nsw i64 1000000000, %633
%635 = sitofp i64 %634 to double
%636 = getelementptr inbounds %struct.timespec, %struct.timespec* %10, i32 0, i32 1
%637 = load double, double* %636
%638 = fadd double %635, %637
%639 = getelementptr inbounds %struct.timespec, %struct.timespec* %9, i32 0, i32 1
%640 = load double, double* %639
%641 = fsub double %638, %640
store double %641, double* %7
%642 = load double, double* %7
%643 = fdiv double %642, 1.000000e+09
%644 = fptrunc double %643 to float
store float %644, float* %8
%645 = load float, float* %8
%646 = call i32 (i8*, float, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i64 0, i64 0), float %645)
ret i32 0
}

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