#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 */

/* Variables and functions */
int /*<<< orphan*/ exit(int /*<<< orphan*/);
scalar_t__ malloc(int);
int omp_get_num_threads();
int omp_get_thread_num();
double omp_get_wtime();
int /*<<< orphan*/ printf(char *, ...);
int main(int argc, char *argv[]) {
  int tid, nthreads, i, j, k;
  double **a, **b, **c;
  double *a_block, *b_block, *c_block;
  double **res;
  double *res_block;
  double starttime, stoptime;
  a = (double **)malloc(10 * sizeof(double *));
  b = (double **)malloc(10 * sizeof(double *));
  c = (double **)malloc(10 * sizeof(double *));
  a_block = (double *)malloc(10 * 10 * sizeof(double));
  b_block = (double *)malloc(10 * 10 * sizeof(double));
  c_block = (double *)malloc(10 * 10 * sizeof(double));
  res = (double **)malloc(10 * sizeof(double *));
  res_block = (double *)malloc(10 * 10 * sizeof(double));
  for (i = 0; i < 10; i++)
    a[i] = a_block + i * 10;
  for (i = 0; i < 10; i++)
    b[i] = b_block + i * 10;
  for (i = 0; i < 10; i++)
    c[i] = c_block + i * 10;
  for (i = 0; i < 10; i++)
    res[i] = res_block + i * 10;
#pragma omp parallel shared(a, b, c, nthreads) private(tid, i, j, k)           \
    num_threads(NR_THREADS)
  {
    tid = omp_get_thread_num();
    if (tid == 0) {
      nthreads = omp_get_num_threads();
      printf("Starting matrix multiplication with %d threads\n", nthreads);
      printf("Initializing matrices...\n");
    }
#pragma omp for nowait
    for (i = 0; i < 10; i++)
      for (j = 0; j < 10; j++)
        a[i][j] = (double)(i + j);
#pragma omp for nowait
    for (i = 0; i < 10; i++)
      for (j = 0; j < 10; j++)
        b[i][j] = (double)(i * j);
#pragma omp for
    for (i = 0; i < 10; i++)
      for (j = 0; j < 10; j++)
        c[i][j] = 0.0;
    if (tid == 0)
      starttime = omp_get_wtime();
#pragma omp for
    for (i = 0; i < 10; i++) {
      if (1)
        printf("Thread=%d did row=%d\n", tid, i);
      for (j = 0; j < 10; j++) {
        for (k = 0; k < 10; k++) {
          c[i][j] += a[i][k] * b[k][j];
        }
      }
    }
    if (tid == 0) {
      stoptime = omp_get_wtime();
      printf("Time for parallel matrix multiplication: %3.2f s\n",
             stoptime - starttime);
    }
  }
  starttime = omp_get_wtime();
  for (i = 0; i < 10; i++) {
    for (j = 0; j < 10; j++) {
      res[i][j] = 0.0;
      for (k = 0; k < 10; k++)
        res[i][j] += a[i][k] * b[k][j];
    }
  }
  stoptime = omp_get_wtime();
  printf("Time for sequential matrix multiplication: %3.2f s\n",
         stoptime - starttime);
  for (i = 0; i < 10; i++) {
    for (j = 0; j < 10; j++) {
      if (res[i][j] == c[i][j]) {
      } else {
        printf("Different result %5.1f != %5.1f in %d %d\n ", res[i][j],
               c[i][j], i, j);
      }
    }
  }
  if (1) {
    printf("Result Matrix:\n");
    for (i = 0; i < 10; i++) {
      for (j = 0; j < 10; j++)
        printf("%6.1f ", c[i][j]);
      printf("\n");
    }
  }
  printf("Done.\n");
  exit(0);
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    $0x50,%edi
call   1070 <malloc@plt>
mov    %rax,-0x30(%rbp)
mov    $0x50,%edi
call   1070 <malloc@plt>
mov    %rax,-0x38(%rbp)
mov    $0x50,%edi
call   1070 <malloc@plt>
mov    %rax,-0x40(%rbp)
mov    $0x320,%edi
call   1070 <malloc@plt>
mov    %rax,-0x48(%rbp)
mov    $0x320,%edi
call   1070 <malloc@plt>
mov    %rax,-0x50(%rbp)
mov    $0x320,%edi
call   1070 <malloc@plt>
mov    %rax,-0x58(%rbp)
mov    $0x50,%edi
call   1070 <malloc@plt>
mov    %rax,-0x60(%rbp)
mov    $0x320,%edi
call   1070 <malloc@plt>
mov    %rax,-0x68(%rbp)
movl   $0x0,-0x1c(%rbp)
cmpl   $0xa,-0x1c(%rbp)
jge    1225 <main+0xc5>
mov    -0x48(%rbp),%rdx
imul   $0xa,-0x1c(%rbp),%eax
cltq
shl    $0x3,%rax
add    %rax,%rdx
mov    -0x30(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11f0 <main+0x90>
movl   $0x0,-0x1c(%rbp)
cmpl   $0xa,-0x1c(%rbp)
jge    1261 <main+0x101>
mov    -0x50(%rbp),%rdx
imul   $0xa,-0x1c(%rbp),%eax
cltq
shl    $0x3,%rax
add    %rax,%rdx
mov    -0x38(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    122c <main+0xcc>
movl   $0x0,-0x1c(%rbp)
cmpl   $0xa,-0x1c(%rbp)
jge    129d <main+0x13d>
mov    -0x58(%rbp),%rdx
imul   $0xa,-0x1c(%rbp),%eax
cltq
shl    $0x3,%rax
add    %rax,%rdx
mov    -0x40(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1268 <main+0x108>
movl   $0x0,-0x1c(%rbp)
cmpl   $0xa,-0x1c(%rbp)
jge    12d9 <main+0x179>
mov    -0x68(%rbp),%rdx
imul   $0xa,-0x1c(%rbp),%eax
cltq
shl    $0x3,%rax
add    %rax,%rdx
mov    -0x60(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    12a4 <main+0x144>
mov    $0x0,%al
call   1030 <omp_get_thread_num@plt>
mov    %eax,-0x14(%rbp)
cmpl   $0x0,-0x14(%rbp)
jne    1316 <main+0x1b6>
mov    $0x0,%al
call   1060 <omp_get_num_threads@plt>
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%esi
lea    0xcff(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0xd21(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x1c(%rbp)
cmpl   $0xa,-0x1c(%rbp)
jge    1378 <main+0x218>
movl   $0x0,-0x20(%rbp)
cmpl   $0xa,-0x20(%rbp)
jge    1365 <main+0x205>
mov    -0x1c(%rbp),%eax
add    -0x20(%rbp),%eax
cvtsi2sd %eax,%xmm0
mov    -0x30(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    132e <main+0x1ce>
jmp    136a <main+0x20a>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    131d <main+0x1bd>
movl   $0x0,-0x1c(%rbp)
cmpl   $0xa,-0x1c(%rbp)
jge    13db <main+0x27b>
movl   $0x0,-0x20(%rbp)
cmpl   $0xa,-0x20(%rbp)
jge    13c8 <main+0x268>
mov    -0x1c(%rbp),%eax
imul   -0x20(%rbp),%eax
cvtsi2sd %eax,%xmm0
mov    -0x38(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1390 <main+0x230>
jmp    13cd <main+0x26d>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    137f <main+0x21f>
movl   $0x0,-0x1c(%rbp)
cmpl   $0xa,-0x1c(%rbp)
jge    1436 <main+0x2d6>
movl   $0x0,-0x20(%rbp)
cmpl   $0xa,-0x20(%rbp)
jge    1423 <main+0x2c3>
mov    -0x40(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    13f3 <main+0x293>
jmp    1428 <main+0x2c8>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    13e2 <main+0x282>
cmpl   $0x0,-0x14(%rbp)
jne    144c <main+0x2ec>
mov    $0x0,%al
call   1040 <omp_get_wtime@plt>
movsd  %xmm0,-0x70(%rbp)
movl   $0x0,-0x1c(%rbp)
cmpl   $0xa,-0x1c(%rbp)
jge    1513 <main+0x3b3>
mov    -0x14(%rbp),%esi
mov    -0x1c(%rbp),%edx
lea    0xbe0(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x20(%rbp)
cmpl   $0xa,-0x20(%rbp)
jge    1500 <main+0x3a0>
movl   $0x0,-0x24(%rbp)
cmpl   $0xa,-0x24(%rbp)
jge    14ed <main+0x38d>
mov    -0x30(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x40(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1489 <main+0x329>
jmp    14f2 <main+0x392>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1478 <main+0x318>
jmp    1505 <main+0x3a5>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1453 <main+0x2f3>
cmpl   $0x0,-0x14(%rbp)
jne    1541 <main+0x3e1>
mov    $0x0,%al
call   1040 <omp_get_wtime@plt>
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
subsd  -0x70(%rbp),%xmm0
lea    0xb26(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    $0x0,%al
call   1040 <omp_get_wtime@plt>
movsd  %xmm0,-0x70(%rbp)
movl   $0x0,-0x1c(%rbp)
cmpl   $0xa,-0x1c(%rbp)
jge    1618 <main+0x4b8>
movl   $0x0,-0x20(%rbp)
cmpl   $0xa,-0x20(%rbp)
jge    1605 <main+0x4a5>
mov    -0x60(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x24(%rbp)
cmpl   $0xa,-0x24(%rbp)
jge    15f2 <main+0x492>
mov    -0x30(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x60(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    158e <main+0x42e>
jmp    15f7 <main+0x497>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1565 <main+0x405>
jmp    160a <main+0x4aa>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1554 <main+0x3f4>
mov    $0x0,%al
call   1040 <omp_get_wtime@plt>
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
subsd  -0x70(%rbp),%xmm0
lea    0xa5d(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
movl   $0x0,-0x1c(%rbp)
cmpl   $0xa,-0x1c(%rbp)
jge    16fd <main+0x59d>
movl   $0x0,-0x20(%rbp)
cmpl   $0xa,-0x20(%rbp)
jge    16ea <main+0x58a>
mov    -0x60(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jne    1699 <main+0x539>
jp     1699 <main+0x539>
jmp    16d7 <main+0x577>
mov    -0x60(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x1c(%rbp),%esi
mov    -0x20(%rbp),%edx
lea    0x9f6(%rip),%rdi
mov    $0x2,%al
call   1050 <printf@plt>
jmp    16dc <main+0x57c>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1654 <main+0x4f4>
jmp    16ef <main+0x58f>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1643 <main+0x4e3>
lea    0x9ed(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x1c(%rbp)
cmpl   $0xa,-0x1c(%rbp)
jge    177a <main+0x61a>
movl   $0x0,-0x20(%rbp)
cmpl   $0xa,-0x20(%rbp)
jge    175e <main+0x5fe>
mov    -0x40(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
lea    0x9b8(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1723 <main+0x5c3>
lea    0x8e3(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1712 <main+0x5b2>
lea    0x987(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
xor    %edi,%edi
call   1080 <exit@plt>

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    $0x50,%edi
call   1090 <malloc@plt>
mov    %rax,%rbp
mov    $0x50,%edi
call   1090 <malloc@plt>
mov    %rax,%r15
mov    $0x50,%edi
call   1090 <malloc@plt>
mov    %rax,%rbx
mov    $0x320,%edi
call   1090 <malloc@plt>
mov    %rax,%r13
mov    $0x320,%edi
call   1090 <malloc@plt>
mov    %rax,%r14
mov    $0x320,%edi
call   1090 <malloc@plt>
mov    %rax,(%rsp)
mov    $0x50,%edi
call   1090 <malloc@plt>
mov    %rax,%r12
mov    $0x320,%edi
call   1090 <malloc@plt>
mov    %r13,0x0(%rbp)
movq   %r13,%xmm0
pshufd $0x44,%xmm0,%xmm4
movdqa 0xdf6(%rip),%xmm0
movdqa %xmm4,%xmm1
paddq  %xmm0,%xmm1
movdqu %xmm1,0x8(%rbp)
movdqa 0xdf1(%rip),%xmm1
movdqa %xmm4,%xmm2
paddq  %xmm1,%xmm2
movdqu %xmm2,0x18(%rbp)
movdqa 0xdec(%rip),%xmm2
movdqa %xmm4,%xmm3
paddq  %xmm2,%xmm3
movdqu %xmm3,0x28(%rbp)
movdqa 0xde7(%rip),%xmm3
paddq  %xmm3,%xmm4
movdqu %xmm4,0x38(%rbp)
add    $0x2d0,%r13
mov    %rbp,0x8(%rsp)
mov    %r13,0x48(%rbp)
mov    %r14,(%r15)
movq   %r14,%xmm4
pshufd $0x44,%xmm4,%xmm4
movdqa %xmm4,%xmm5
paddq  %xmm0,%xmm5
movdqu %xmm5,0x8(%r15)
movdqa %xmm4,%xmm5
paddq  %xmm1,%xmm5
movdqu %xmm5,0x18(%r15)
movdqa %xmm4,%xmm5
paddq  %xmm2,%xmm5
movdqu %xmm5,0x28(%r15)
paddq  %xmm3,%xmm4
movdqu %xmm4,0x38(%r15)
add    $0x2d0,%r14
mov    %r14,0x48(%r15)
mov    (%rsp),%rcx
mov    %rcx,(%rbx)
movq   %rcx,%xmm4
pshufd $0x44,%xmm4,%xmm4
movdqa %xmm4,%xmm5
paddq  %xmm0,%xmm5
movdqu %xmm5,0x8(%rbx)
movdqa %xmm4,%xmm5
paddq  %xmm1,%xmm5
movdqu %xmm5,0x18(%rbx)
movdqa %xmm4,%xmm5
paddq  %xmm2,%xmm5
movdqu %xmm5,0x28(%rbx)
paddq  %xmm3,%xmm4
movdqu %xmm4,0x38(%rbx)
add    $0x2d0,%rcx
mov    %rcx,0x48(%rbx)
mov    %rax,(%r12)
movq   %rax,%xmm4
pshufd $0x44,%xmm4,%xmm4
paddq  %xmm4,%xmm0
movdqu %xmm0,0x8(%r12)
paddq  %xmm4,%xmm1
movdqu %xmm1,0x18(%r12)
paddq  %xmm4,%xmm2
movdqu %xmm2,0x28(%r12)
paddq  %xmm3,%xmm4
movdqu %xmm4,0x38(%r12)
add    $0x2d0,%rax
mov    %r12,0x20(%rsp)
mov    %rax,0x48(%r12)
xor    %eax,%eax
call   1050 <omp_get_thread_num@plt>
mov    %eax,(%rsp)
test   %eax,%eax
jne    1375 <main+0x1f5>
xor    %eax,%eax
call   1080 <omp_get_num_threads@plt>
lea    0x1038(%rip),%rdi
mov    %eax,%esi
xor    %eax,%eax
call   1070 <printf@plt>
lea    0x111b(%rip),%rdi
call   1040 <puts@plt>
mov    0x8(%rsp),%rcx
mov    (%rcx),%rax
pxor   %xmm0,%xmm0
pxor   %xmm1,%xmm1
movhps 0xfc4(%rip),%xmm1
movups %xmm1,(%rax)
movaps 0xca9(%rip),%xmm8
movups %xmm8,0x10(%rax)
movaps 0xcac(%rip),%xmm9
movups %xmm9,0x20(%rax)
movaps 0xcaf(%rip),%xmm10
movups %xmm10,0x30(%rax)
movaps 0xcb2(%rip),%xmm11
movups %xmm11,0x40(%rax)
mov    0x8(%rcx),%rax
movaps 0xcb2(%rip),%xmm2
movups %xmm2,(%rax)
movaps 0xcb8(%rip),%xmm3
movups %xmm3,0x10(%rax)
movaps 0xcbd(%rip),%xmm4
movups %xmm4,0x20(%rax)
movaps 0xcc1(%rip),%xmm12
movups %xmm12,0x30(%rax)
movaps 0xcc4(%rip),%xmm13
movups %xmm13,0x40(%rax)
mov    0x10(%rcx),%rax
movups %xmm8,(%rax)
movups %xmm9,0x10(%rax)
movups %xmm10,0x20(%rax)
movups %xmm11,0x30(%rax)
movaps 0xcb1(%rip),%xmm2
movups %xmm2,0x40(%rax)
mov    0x18(%rcx),%rax
movups %xmm3,(%rax)
movups %xmm4,0x10(%rax)
movups %xmm12,0x20(%rax)
movups %xmm13,0x30(%rax)
movaps 0xca1(%rip),%xmm3
movups %xmm3,0x40(%rax)
mov    0x20(%rcx),%rax
movups %xmm9,(%rax)
movups %xmm10,0x10(%rax)
movups %xmm11,0x20(%rax)
movups %xmm2,0x30(%rax)
movaps 0xc90(%rip),%xmm5
movups %xmm5,0x40(%rax)
mov    0x28(%rcx),%rax
movups %xmm4,(%rax)
movups %xmm12,0x10(%rax)
movups %xmm13,0x20(%rax)
movups %xmm3,0x30(%rax)
movaps 0xc80(%rip),%xmm4
movups %xmm4,0x40(%rax)
mov    0x30(%rcx),%rax
movups %xmm10,(%rax)
movups %xmm11,0x10(%rax)
movups %xmm2,0x20(%rax)
movups %xmm5,0x30(%rax)
movaps 0xc70(%rip),%xmm7
movups %xmm7,0x40(%rax)
mov    0x38(%rcx),%rax
movups %xmm12,(%rax)
movups %xmm13,0x10(%rax)
movups %xmm3,0x20(%rax)
movups %xmm4,0x30(%rax)
movaps 0xc60(%rip),%xmm6
movups %xmm6,0x40(%rax)
mov    0x40(%rcx),%rax
movups %xmm11,(%rax)
movups %xmm2,0x10(%rax)
movups %xmm5,0x20(%rax)
movups %xmm7,0x30(%rax)
movaps 0xc51(%rip),%xmm2
movups %xmm2,0x40(%rax)
mov    0x48(%rcx),%rax
movups %xmm13,(%rax)
movups %xmm3,0x10(%rax)
movups %xmm4,0x20(%rax)
movups %xmm6,0x30(%rax)
movapd 0xc41(%rip),%xmm2
movupd %xmm2,0x40(%rax)
mov    (%r15),%rax
movdqu %xmm0,0x40(%rax)
movdqu %xmm0,0x30(%rax)
movdqu %xmm0,0x20(%rax)
movdqu %xmm0,0x10(%rax)
movdqu %xmm0,(%rax)
mov    0x8(%r15),%rax
movups %xmm1,(%rax)
movups %xmm8,0x10(%rax)
movups %xmm9,0x20(%rax)
movups %xmm10,0x30(%rax)
movups %xmm11,0x40(%rax)
mov    0x10(%r15),%rax
xorps  %xmm1,%xmm1
movhps 0xe10(%rip),%xmm1
movups %xmm1,(%rax)
movaps 0xbfe(%rip),%xmm1
movups %xmm1,0x10(%rax)
movaps 0xc03(%rip),%xmm1
movups %xmm1,0x20(%rax)
movaps 0xc08(%rip),%xmm1
movups %xmm1,0x30(%rax)
movaps 0xc0d(%rip),%xmm1
movups %xmm1,0x40(%rax)
mov    0x18(%r15),%rax
xorps  %xmm1,%xmm1
movhps 0xddb(%rip),%xmm1
movups %xmm1,(%rax)
movaps 0xc01(%rip),%xmm1
movups %xmm1,0x10(%rax)
movaps 0xc06(%rip),%xmm1
movups %xmm1,0x20(%rax)
movaps 0xc0b(%rip),%xmm1
movups %xmm1,0x30(%rax)
movaps 0xc10(%rip),%xmm1
movups %xmm1,0x40(%rax)
xorps  %xmm1,%xmm1
movhps 0xdaa(%rip),%xmm1
mov    0x20(%r15),%rax
movups %xmm1,(%rax)
movaps 0xc04(%rip),%xmm1
movups %xmm1,0x10(%rax)
movaps 0xc09(%rip),%xmm1
movups %xmm1,0x20(%rax)
movaps 0xc0e(%rip),%xmm1
movups %xmm1,0x30(%rax)
movaps 0xc13(%rip),%xmm1
movups %xmm1,0x40(%rax)
mov    0x28(%r15),%rax
xorps  %xmm1,%xmm1
movhps 0xd71(%rip),%xmm1
movups %xmm1,(%rax)
movaps 0xc07(%rip),%xmm1
movups %xmm1,0x10(%rax)
movaps 0xc0c(%rip),%xmm1
movups %xmm1,0x20(%rax)
movaps 0xc11(%rip),%xmm1
movups %xmm1,0x30(%rax)
movaps 0xc16(%rip),%xmm1
movups %xmm1,0x40(%rax)
mov    0x30(%r15),%rax
xorps  %xmm1,%xmm1
movhps 0xd3c(%rip),%xmm1
movups %xmm1,(%rax)
movaps 0xc0a(%rip),%xmm1
movups %xmm1,0x10(%rax)
movaps 0xc0f(%rip),%xmm1
movups %xmm1,0x20(%rax)
movaps 0xc14(%rip),%xmm1
movups %xmm1,0x30(%rax)
movaps 0xc19(%rip),%xmm1
movups %xmm1,0x40(%rax)
mov    0x38(%r15),%rax
xorps  %xmm1,%xmm1
movhps 0xd07(%rip),%xmm1
movups %xmm1,(%rax)
movaps 0xc0d(%rip),%xmm1
movups %xmm1,0x10(%rax)
movaps 0xc12(%rip),%xmm1
movups %xmm1,0x20(%rax)
movaps 0xc17(%rip),%xmm1
movups %xmm1,0x30(%rax)
movaps 0xc1c(%rip),%xmm1
movups %xmm1,0x40(%rax)
xorps  %xmm1,%xmm1
movhps 0xcd6(%rip),%xmm1
mov    0x40(%r15),%rax
movups %xmm1,(%rax)
movaps 0xc10(%rip),%xmm1
movups %xmm1,0x10(%rax)
movaps 0xc15(%rip),%xmm1
movups %xmm1,0x20(%rax)
movaps 0xc1a(%rip),%xmm1
movups %xmm1,0x30(%rax)
movaps 0xc1f(%rip),%xmm1
movups %xmm1,0x40(%rax)
mov    0x48(%r15),%rax
xorps  %xmm1,%xmm1
movhps 0xc9d(%rip),%xmm1
movups %xmm1,(%rax)
movaps 0xc13(%rip),%xmm1
movups %xmm1,0x10(%rax)
movaps 0xc18(%rip),%xmm1
movups %xmm1,0x20(%rax)
movaps 0xc1d(%rip),%xmm1
movups %xmm1,0x30(%rax)
movapd 0xc21(%rip),%xmm1
movupd %xmm1,0x40(%rax)
mov    (%rbx),%rax
movdqu %xmm0,0x40(%rax)
movdqu %xmm0,0x30(%rax)
movdqu %xmm0,0x20(%rax)
movdqu %xmm0,0x10(%rax)
movdqu %xmm0,(%rax)
mov    0x8(%rbx),%rax
movdqu %xmm0,0x40(%rax)
movdqu %xmm0,0x30(%rax)
movdqu %xmm0,0x20(%rax)
movdqu %xmm0,0x10(%rax)
movdqu %xmm0,(%rax)
mov    0x10(%rbx),%rax
movdqu %xmm0,0x40(%rax)
movdqu %xmm0,0x30(%rax)
movdqu %xmm0,0x20(%rax)
movdqu %xmm0,0x10(%rax)
movdqu %xmm0,(%rax)
mov    0x18(%rbx),%rax
movdqu %xmm0,0x40(%rax)
movdqu %xmm0,0x30(%rax)
movdqu %xmm0,0x20(%rax)
movdqu %xmm0,0x10(%rax)
movdqu %xmm0,(%rax)
mov    0x20(%rbx),%rax
movdqu %xmm0,0x40(%rax)
movdqu %xmm0,0x30(%rax)
movdqu %xmm0,0x20(%rax)
movdqu %xmm0,0x10(%rax)
movdqu %xmm0,(%rax)
mov    0x28(%rbx),%rax
movdqu %xmm0,0x40(%rax)
movdqu %xmm0,0x30(%rax)
movdqu %xmm0,0x20(%rax)
movdqu %xmm0,0x10(%rax)
movdqu %xmm0,(%rax)
mov    0x30(%rbx),%rax
movdqu %xmm0,0x40(%rax)
movdqu %xmm0,0x30(%rax)
movdqu %xmm0,0x20(%rax)
movdqu %xmm0,0x10(%rax)
movdqu %xmm0,(%rax)
mov    0x38(%rbx),%rax
movdqu %xmm0,0x40(%rax)
movdqu %xmm0,0x30(%rax)
movdqu %xmm0,0x20(%rax)
movdqu %xmm0,0x10(%rax)
movdqu %xmm0,(%rax)
mov    0x40(%rbx),%rax
movdqu %xmm0,0x40(%rax)
movdqu %xmm0,0x30(%rax)
movdqu %xmm0,0x20(%rax)
movdqu %xmm0,0x10(%rax)
movdqu %xmm0,(%rax)
mov    0x48(%rbx),%rax
movdqu %xmm0,0x40(%rax)
movdqu %xmm0,0x30(%rax)
movdqu %xmm0,0x20(%rax)
movdqu %xmm0,0x10(%rax)
movdqu %xmm0,(%rax)
cmpl   $0x0,(%rsp)
jne    184e <main+0x6ce>
xor    %eax,%eax
call   1060 <omp_get_wtime@plt>
movsd  %xmm0,0x18(%rsp)
xor    %r13d,%r13d
mov    %rbx,0x10(%rsp)
cs nopw 0x0(%rax,%rax,1)
lea    0xb61(%rip),%rdi
mov    (%rsp),%esi
mov    %r13d,%edx
xor    %eax,%eax
call   1070 <printf@plt>
mov    0x8(%rsp),%rax
mov    (%rax,%r13,8),%rax
mov    (%rbx,%r13,8),%rcx
mov    (%r15),%r8
mov    0x8(%r15),%r9
mov    0x10(%r15),%r10
mov    0x18(%r15),%r11
mov    0x20(%r15),%r14
mov    0x28(%r15),%r12
mov    0x30(%r15),%rsi
mov    0x38(%r15),%rdi
mov    0x40(%r15),%rbx
mov    0x48(%r15),%rbp
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movsd  (%rax),%xmm0
mulsd  (%r8,%rdx,1),%xmm0
addsd  (%rcx,%rdx,1),%xmm0
movsd  %xmm0,(%rcx,%rdx,1)
movsd  0x8(%rax),%xmm1
mulsd  (%r9,%rdx,1),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rcx,%rdx,1)
movsd  0x10(%rax),%xmm0
mulsd  (%r10,%rdx,1),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rcx,%rdx,1)
movsd  0x18(%rax),%xmm1
mulsd  (%r11,%rdx,1),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rcx,%rdx,1)
movsd  0x20(%rax),%xmm0
mulsd  (%r14,%rdx,1),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rcx,%rdx,1)
movsd  0x28(%rax),%xmm1
mulsd  (%r12,%rdx,1),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rcx,%rdx,1)
movsd  0x30(%rax),%xmm0
mulsd  (%rsi,%rdx,1),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rcx,%rdx,1)
movsd  0x38(%rax),%xmm1
mulsd  (%rdi,%rdx,1),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rcx,%rdx,1)
movsd  0x40(%rax),%xmm0
mulsd  (%rbx,%rdx,1),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rcx,%rdx,1)
movsd  0x48(%rax),%xmm1
mulsd  0x0(%rbp,%rdx,1),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rcx,%rdx,1)
add    $0x8,%rdx
cmp    $0x50,%rdx
jne    18b0 <main+0x730>
add    $0x1,%r13
cmp    $0xa,%r13
mov    0x10(%rsp),%rbx
jne    1860 <main+0x6e0>
cmpl   $0x0,(%rsp)
jne    19b7 <main+0x837>
xor    %eax,%eax
call   1060 <omp_get_wtime@plt>
subsd  0x18(%rsp),%xmm0
lea    0xa2e(%rip),%rdi
mov    $0x1,%al
call   1070 <printf@plt>
xor    %r13d,%r13d
xor    %eax,%eax
call   1060 <omp_get_wtime@plt>
movsd  %xmm0,(%rsp)
mov    (%r15),%r8
mov    0x8(%r15),%r9
mov    0x10(%r15),%r10
mov    0x18(%r15),%r11
mov    0x20(%r15),%r14
mov    0x28(%r15),%r12
mov    0x30(%r15),%rbp
mov    0x38(%r15),%rax
mov    0x40(%r15),%rcx
mov    0x48(%r15),%rdx
xorpd  %xmm0,%xmm0
mov    0x20(%rsp),%r15
cs nopw 0x0(%rax,%rax,1)
mov    (%r15,%r13,8),%rsi
mov    0x8(%rsp),%rdi
mov    (%rdi,%r13,8),%rdi
xor    %ebx,%ebx
nop
movq   $0x0,(%rsi,%rbx,1)
movsd  (%rdi),%xmm1
mulsd  (%r8,%rbx,1),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rsi,%rbx,1)
movsd  0x8(%rdi),%xmm2
mulsd  (%r9,%rbx,1),%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,(%rsi,%rbx,1)
movsd  0x10(%rdi),%xmm1
mulsd  (%r10,%rbx,1),%xmm1
addsd  %xmm2,%xmm1
movsd  %xmm1,(%rsi,%rbx,1)
movsd  0x18(%rdi),%xmm2
mulsd  (%r11,%rbx,1),%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,(%rsi,%rbx,1)
movsd  0x20(%rdi),%xmm1
mulsd  (%r14,%rbx,1),%xmm1
addsd  %xmm2,%xmm1
movsd  %xmm1,(%rsi,%rbx,1)
movsd  0x28(%rdi),%xmm2
mulsd  (%r12,%rbx,1),%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,(%rsi,%rbx,1)
movsd  0x30(%rdi),%xmm1
mulsd  0x0(%rbp,%rbx,1),%xmm1
addsd  %xmm2,%xmm1
movsd  %xmm1,(%rsi,%rbx,1)
movsd  0x38(%rdi),%xmm2
mulsd  (%rax,%rbx,1),%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,(%rsi,%rbx,1)
movsd  0x40(%rdi),%xmm1
mulsd  (%rcx,%rbx,1),%xmm1
addsd  %xmm2,%xmm1
movsd  %xmm1,(%rsi,%rbx,1)
movsd  0x48(%rdi),%xmm2
mulsd  (%rdx,%rbx,1),%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,(%rsi,%rbx,1)
add    $0x8,%rbx
cmp    $0x50,%rbx
jne    1a10 <main+0x890>
add    $0x1,%r13
cmp    $0xa,%r13
jne    1a00 <main+0x880>
xor    %ebx,%ebx
xor    %eax,%eax
call   1060 <omp_get_wtime@plt>
subsd  (%rsp),%xmm0
lea    0x903(%rip),%rdi
mov    $0x1,%al
call   1070 <printf@plt>
lea    0x929(%rip),%rbp
mov    0x10(%rsp),%r14
jmp    1b3e <main+0x9be>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rbx
cmp    $0xa,%rbx
je     1cf0 <main+0xb70>
mov    (%r15,%rbx,8),%rax
movsd  (%rax),%xmm0
mov    (%r14,%rbx,8),%rcx
movsd  (%rcx),%xmm1
ucomisd %xmm1,%xmm0
jne    1b56 <main+0x9d6>
jnp    1b6c <main+0x9ec>
mov    %rbp,%rdi
mov    %ebx,%esi
xor    %edx,%edx
mov    $0x2,%al
call   1070 <printf@plt>
mov    (%r15,%rbx,8),%rax
mov    (%r14,%rbx,8),%rcx
movsd  0x8(%rax),%xmm0
movsd  0x8(%rcx),%xmm1
ucomisd %xmm1,%xmm0
jne    1b7e <main+0x9fe>
jnp    1b97 <main+0xa17>
mov    %rbp,%rdi
mov    %ebx,%esi
mov    $0x1,%edx
mov    $0x2,%al
call   1070 <printf@plt>
mov    (%r15,%rbx,8),%rax
mov    (%r14,%rbx,8),%rcx
movsd  0x10(%rax),%xmm0
movsd  0x10(%rcx),%xmm1
ucomisd %xmm1,%xmm0
jne    1ba9 <main+0xa29>
jnp    1bc2 <main+0xa42>
mov    %rbp,%rdi
mov    %ebx,%esi
mov    $0x2,%edx
mov    $0x2,%al
call   1070 <printf@plt>
mov    (%r15,%rbx,8),%rax
mov    (%r14,%rbx,8),%rcx
movsd  0x18(%rax),%xmm0
movsd  0x18(%rcx),%xmm1
ucomisd %xmm1,%xmm0
jne    1bd4 <main+0xa54>
jnp    1bed <main+0xa6d>
mov    %rbp,%rdi
mov    %ebx,%esi
mov    $0x3,%edx
mov    $0x2,%al
call   1070 <printf@plt>
mov    (%r15,%rbx,8),%rax
mov    (%r14,%rbx,8),%rcx
movsd  0x20(%rax),%xmm0
movsd  0x20(%rcx),%xmm1
ucomisd %xmm1,%xmm0
jne    1bff <main+0xa7f>
jnp    1c18 <main+0xa98>
mov    %rbp,%rdi
mov    %ebx,%esi
mov    $0x4,%edx
mov    $0x2,%al
call   1070 <printf@plt>
mov    (%r15,%rbx,8),%rax
mov    (%r14,%rbx,8),%rcx
movsd  0x28(%rax),%xmm0
movsd  0x28(%rcx),%xmm1
ucomisd %xmm1,%xmm0
jne    1c2a <main+0xaaa>
jnp    1c43 <main+0xac3>
mov    %rbp,%rdi
mov    %ebx,%esi
mov    $0x5,%edx
mov    $0x2,%al
call   1070 <printf@plt>
mov    (%r15,%rbx,8),%rax
mov    (%r14,%rbx,8),%rcx
movsd  0x30(%rax),%xmm0
movsd  0x30(%rcx),%xmm1
ucomisd %xmm1,%xmm0
jne    1c55 <main+0xad5>
jnp    1c6e <main+0xaee>
mov    %rbp,%rdi
mov    %ebx,%esi
mov    $0x6,%edx
mov    $0x2,%al
call   1070 <printf@plt>
mov    (%r15,%rbx,8),%rax
mov    (%r14,%rbx,8),%rcx
movsd  0x38(%rax),%xmm0
movsd  0x38(%rcx),%xmm1
ucomisd %xmm1,%xmm0
jne    1c80 <main+0xb00>
jnp    1c99 <main+0xb19>
mov    %rbp,%rdi
mov    %ebx,%esi
mov    $0x7,%edx
mov    $0x2,%al
call   1070 <printf@plt>
mov    (%r15,%rbx,8),%rax
mov    (%r14,%rbx,8),%rcx
movsd  0x40(%rax),%xmm0
movsd  0x40(%rcx),%xmm1
ucomisd %xmm1,%xmm0
jne    1cab <main+0xb2b>
jnp    1cc4 <main+0xb44>
mov    %rbp,%rdi
mov    %ebx,%esi
mov    $0x8,%edx
mov    $0x2,%al
call   1070 <printf@plt>
mov    (%r15,%rbx,8),%rax
mov    (%r14,%rbx,8),%rcx
movsd  0x48(%rax),%xmm0
movsd  0x48(%rcx),%xmm1
ucomisd %xmm1,%xmm0
jne    1cda <main+0xb5a>
jnp    1b30 <main+0x9b0>
mov    %rbp,%rdi
mov    %ebx,%esi
mov    $0x9,%edx
mov    $0x2,%al
call   1070 <printf@plt>
jmp    1b30 <main+0x9b0>
lea    0x77f(%rip),%rdi
call   1040 <puts@plt>
xor    %ebp,%ebp
lea    0x76a(%rip),%rbx
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%r14,%rbp,8),%rax
movsd  (%rax),%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1070 <printf@plt>
mov    (%r14,%rbp,8),%rax
movsd  0x8(%rax),%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1070 <printf@plt>
mov    (%r14,%rbp,8),%rax
movsd  0x10(%rax),%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1070 <printf@plt>
mov    (%r14,%rbp,8),%rax
movsd  0x18(%rax),%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1070 <printf@plt>
mov    (%r14,%rbp,8),%rax
movsd  0x20(%rax),%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1070 <printf@plt>
mov    (%r14,%rbp,8),%rax
movsd  0x28(%rax),%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1070 <printf@plt>
mov    (%r14,%rbp,8),%rax
movsd  0x30(%rax),%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1070 <printf@plt>
mov    (%r14,%rbp,8),%rax
movsd  0x38(%rax),%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1070 <printf@plt>
mov    (%r14,%rbp,8),%rax
movsd  0x40(%rax),%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1070 <printf@plt>
mov    (%r14,%rbp,8),%rax
movsd  0x48(%rax),%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1070 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
add    $0x1,%rbp
cmp    $0xa,%rbp
jne    1d10 <main+0xb90>
lea    0x699(%rip),%rdi
call   1040 <puts@plt>
xor    %edi,%edi
call   10a0 <exit@plt>

LLVM IR (-O0):
@.str = [48 x i8] c"Starting matrix multiplication with %d threads\0A\00"
@.str.1 = [26 x i8] c"Initializing matrices...\0A\00"
@.str.2 = [22 x i8] c"Thread=%d did row=%d\0A\00"
@.str.3 = [50 x i8] c"Time for parallel matrix multiplication: %3.2f s\0A\00"
@.str.4 = [52 x i8] c"Time for sequential matrix multiplication: %3.2f s\0A\00"
@.str.5 = [43 x i8] c"Different result %5.1f != %5.1f in %d %d\0A \00"
@.str.6 = [16 x i8] c"Result Matrix:\0A\00"
@.str.7 = [7 x i8] c"%6.1f \00"
@.str.8 = [2 x i8] c"\0A\00"
@.str.9 = [7 x i8] c"Done.\0A\00"
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8**
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca double**
%12 = alloca double**
%13 = alloca double**
%14 = alloca double*
%15 = alloca double*
%16 = alloca double*
%17 = alloca double**
%18 = alloca double*
%19 = alloca double
%20 = alloca double
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
%21 = call i64 @malloc(i32 80)
%22 = inttoptr i64 %21 to double**
store double** %22, double*** %11
%23 = call i64 @malloc(i32 80)
%24 = inttoptr i64 %23 to double**
store double** %24, double*** %12
%25 = call i64 @malloc(i32 80)
%26 = inttoptr i64 %25 to double**
store double** %26, double*** %13
%27 = call i64 @malloc(i32 800)
%28 = inttoptr i64 %27 to double*
store double* %28, double** %14
%29 = call i64 @malloc(i32 800)
%30 = inttoptr i64 %29 to double*
store double* %30, double** %15
%31 = call i64 @malloc(i32 800)
%32 = inttoptr i64 %31 to double*
store double* %32, double** %16
%33 = call i64 @malloc(i32 80)
%34 = inttoptr i64 %33 to double**
store double** %34, double*** %17
%35 = call i64 @malloc(i32 800)
%36 = inttoptr i64 %35 to double*
store double* %36, double** %18
store i32 0, i32* %8
br label %37
37: ; preds = %50, %2
%38 = load i32, i32* %8
%39 = icmp slt i32 %38, 10
br i1 %39, label %40, label %53
40: ; preds = %37
%41 = load double*, double** %14
%42 = load i32, i32* %8
%43 = mul nsw i32 %42, 10
%44 = sext i32 %43 to i64
%45 = getelementptr inbounds double, double* %41, i64 %44
%46 = load double**, double*** %11
%47 = load i32, i32* %8
%48 = sext i32 %47 to i64
%49 = getelementptr inbounds double*, double** %46, i64 %48
store double* %45, double** %49
br label %50
50: ; preds = %40
%51 = load i32, i32* %8
%52 = add nsw i32 %51, 1
store i32 %52, i32* %8
br label %37
53: ; preds = %37
store i32 0, i32* %8
br label %54
54: ; preds = %67, %53
%55 = load i32, i32* %8
%56 = icmp slt i32 %55, 10
br i1 %56, label %57, label %70
57: ; preds = %54
%58 = load double*, double** %15
%59 = load i32, i32* %8
%60 = mul nsw i32 %59, 10
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds double, double* %58, i64 %61
%63 = load double**, double*** %12
%64 = load i32, i32* %8
%65 = sext i32 %64 to i64
%66 = getelementptr inbounds double*, double** %63, i64 %65
store double* %62, double** %66
br label %67
67: ; preds = %57
%68 = load i32, i32* %8
%69 = add nsw i32 %68, 1
store i32 %69, i32* %8
br label %54
70: ; preds = %54
store i32 0, i32* %8
br label %71
71: ; preds = %84, %70
%72 = load i32, i32* %8
%73 = icmp slt i32 %72, 10
br i1 %73, label %74, label %87
74: ; preds = %71
%75 = load double*, double** %16
%76 = load i32, i32* %8
%77 = mul nsw i32 %76, 10
%78 = sext i32 %77 to i64
%79 = getelementptr inbounds double, double* %75, i64 %78
%80 = load double**, double*** %13
%81 = load i32, i32* %8
%82 = sext i32 %81 to i64
%83 = getelementptr inbounds double*, double** %80, i64 %82
store double* %79, double** %83
br label %84
84: ; preds = %74
%85 = load i32, i32* %8
%86 = add nsw i32 %85, 1
store i32 %86, i32* %8
br label %71
87: ; preds = %71
store i32 0, i32* %8
br label %88
88: ; preds = %101, %87
%89 = load i32, i32* %8
%90 = icmp slt i32 %89, 10
br i1 %90, label %91, label %104
91: ; preds = %88
%92 = load double*, double** %18
%93 = load i32, i32* %8
%94 = mul nsw i32 %93, 10
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds double, double* %92, i64 %95
%97 = load double**, double*** %17
%98 = load i32, i32* %8
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds double*, double** %97, i64 %99
store double* %96, double** %100
br label %101
101: ; preds = %91
%102 = load i32, i32* %8
%103 = add nsw i32 %102, 1
store i32 %103, i32* %8
br label %88
104: ; preds = %88
%105 = call i32 (...) @omp_get_thread_num()
store i32 %105, i32* %6
%106 = load i32, i32* %6
%107 = icmp eq i32 %106, 0
br i1 %107, label %108, label %113
108: ; preds = %104
%109 = call i32 (...) @omp_get_num_threads()
store i32 %109, i32* %7
%110 = load i32, i32* %7
%111 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([48 x i8], [48 x i8]* @.str, i64 0, i64 0), i32 %110)
%112 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.1, i64 0, i64 0))
br label %113
113: ; preds = %108, %104
store i32 0, i32* %8
br label %114
114: ; preds = %138, %113
%115 = load i32, i32* %8
%116 = icmp slt i32 %115, 10
br i1 %116, label %117, label %141
117: ; preds = %114
store i32 0, i32* %9
br label %118
118: ; preds = %134, %117
%119 = load i32, i32* %9
%120 = icmp slt i32 %119, 10
br i1 %120, label %121, label %137
121: ; preds = %118
%122 = load i32, i32* %8
%123 = load i32, i32* %9
%124 = add nsw i32 %122, %123
%125 = sitofp i32 %124 to double
%126 = load double**, double*** %11
%127 = load i32, i32* %8
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds double*, double** %126, i64 %128
%130 = load double*, double** %129
%131 = load i32, i32* %9
%132 = sext i32 %131 to i64
%133 = getelementptr inbounds double, double* %130, i64 %132
store double %125, double* %133
br label %134
134: ; preds = %121
%135 = load i32, i32* %9
%136 = add nsw i32 %135, 1
store i32 %136, i32* %9
br label %118
137: ; preds = %118
br label %138
138: ; preds = %137
%139 = load i32, i32* %8
%140 = add nsw i32 %139, 1
store i32 %140, i32* %8
br label %114
141: ; preds = %114
store i32 0, i32* %8
br label %142
142: ; preds = %166, %141
%143 = load i32, i32* %8
%144 = icmp slt i32 %143, 10
br i1 %144, label %145, label %169
145: ; preds = %142
store i32 0, i32* %9
br label %146
146: ; preds = %162, %145
%147 = load i32, i32* %9
%148 = icmp slt i32 %147, 10
br i1 %148, label %149, label %165
149: ; preds = %146
%150 = load i32, i32* %8
%151 = load i32, i32* %9
%152 = mul nsw i32 %150, %151
%153 = sitofp i32 %152 to double
%154 = load double**, double*** %12
%155 = load i32, i32* %8
%156 = sext i32 %155 to i64
%157 = getelementptr inbounds double*, double** %154, i64 %156
%158 = load double*, double** %157
%159 = load i32, i32* %9
%160 = sext i32 %159 to i64
%161 = getelementptr inbounds double, double* %158, i64 %160
store double %153, double* %161
br label %162
162: ; preds = %149
%163 = load i32, i32* %9
%164 = add nsw i32 %163, 1
store i32 %164, i32* %9
br label %146
165: ; preds = %146
br label %166
166: ; preds = %165
%167 = load i32, i32* %8
%168 = add nsw i32 %167, 1
store i32 %168, i32* %8
br label %142
169: ; preds = %142
store i32 0, i32* %8
br label %170
170: ; preds = %190, %169
%171 = load i32, i32* %8
%172 = icmp slt i32 %171, 10
br i1 %172, label %173, label %193
173: ; preds = %170
store i32 0, i32* %9
br label %174
174: ; preds = %186, %173
%175 = load i32, i32* %9
%176 = icmp slt i32 %175, 10
br i1 %176, label %177, label %189
177: ; preds = %174
%178 = load double**, double*** %13
%179 = load i32, i32* %8
%180 = sext i32 %179 to i64
%181 = getelementptr inbounds double*, double** %178, i64 %180
%182 = load double*, double** %181
%183 = load i32, i32* %9
%184 = sext i32 %183 to i64
%185 = getelementptr inbounds double, double* %182, i64 %184
store double 0.000000e+00, double* %185
br label %186
186: ; preds = %177
%187 = load i32, i32* %9
%188 = add nsw i32 %187, 1
store i32 %188, i32* %9
br label %174
189: ; preds = %174
br label %190
190: ; preds = %189
%191 = load i32, i32* %8
%192 = add nsw i32 %191, 1
store i32 %192, i32* %8
br label %170
193: ; preds = %170
%194 = load i32, i32* %6
%195 = icmp eq i32 %194, 0
br i1 %195, label %196, label %198
196: ; preds = %193
%197 = call double (...) @omp_get_wtime()
store double %197, double* %19
br label %198
198: ; preds = %196, %193
store i32 0, i32* %8
br label %199
199: ; preds = %250, %198
%200 = load i32, i32* %8
%201 = icmp slt i32 %200, 10
br i1 %201, label %202, label %253
202: ; preds = %199
%203 = load i32, i32* %6
%204 = load i32, i32* %8
%205 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.2, i64 0, i64 0), i32 %203, i32 %204)
store i32 0, i32* %9
br label %206
206: ; preds = %246, %202
%207 = load i32, i32* %9
%208 = icmp slt i32 %207, 10
br i1 %208, label %209, label %249
209: ; preds = %206
store i32 0, i32* %10
br label %210
210: ; preds = %242, %209
%211 = load i32, i32* %10
%212 = icmp slt i32 %211, 10
br i1 %212, label %213, label %245
213: ; preds = %210
%214 = load double**, double*** %11
%215 = load i32, i32* %8
%216 = sext i32 %215 to i64
%217 = getelementptr inbounds double*, double** %214, i64 %216
%218 = load double*, double** %217
%219 = load i32, i32* %10
%220 = sext i32 %219 to i64
%221 = getelementptr inbounds double, double* %218, i64 %220
%222 = load double, double* %221
%223 = load double**, double*** %12
%224 = load i32, i32* %10
%225 = sext i32 %224 to i64
%226 = getelementptr inbounds double*, double** %223, i64 %225
%227 = load double*, double** %226
%228 = load i32, i32* %9
%229 = sext i32 %228 to i64
%230 = getelementptr inbounds double, double* %227, i64 %229
%231 = load double, double* %230
%232 = load double**, double*** %13
%233 = load i32, i32* %8
%234 = sext i32 %233 to i64
%235 = getelementptr inbounds double*, double** %232, i64 %234
%236 = load double*, double** %235
%237 = load i32, i32* %9
%238 = sext i32 %237 to i64
%239 = getelementptr inbounds double, double* %236, i64 %238
%240 = load double, double* %239
%241 = call double @llvm.fmuladd.f64(double %222, double %231, double %240)
store double %241, double* %239
br label %242
242: ; preds = %213
%243 = load i32, i32* %10
%244 = add nsw i32 %243, 1
store i32 %244, i32* %10
br label %210
245: ; preds = %210
br label %246
246: ; preds = %245
%247 = load i32, i32* %9
%248 = add nsw i32 %247, 1
store i32 %248, i32* %9
br label %206
249: ; preds = %206
br label %250
250: ; preds = %249
%251 = load i32, i32* %8
%252 = add nsw i32 %251, 1
store i32 %252, i32* %8
br label %199
253: ; preds = %199
%254 = load i32, i32* %6
%255 = icmp eq i32 %254, 0
br i1 %255, label %256, label %262
256: ; preds = %253
%257 = call double (...) @omp_get_wtime()
store double %257, double* %20
%258 = load double, double* %20
%259 = load double, double* %19
%260 = fsub double %258, %259
%261 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.3, i64 0, i64 0), double %260)
br label %262
262: ; preds = %256, %253
%263 = call double (...) @omp_get_wtime()
store double %263, double* %19
store i32 0, i32* %8
br label %264
264: ; preds = %320, %262
%265 = load i32, i32* %8
%266 = icmp slt i32 %265, 10
br i1 %266, label %267, label %323
267: ; preds = %264
store i32 0, i32* %9
br label %268
268: ; preds = %316, %267
%269 = load i32, i32* %9
%270 = icmp slt i32 %269, 10
br i1 %270, label %271, label %319
271: ; preds = %268
%272 = load double**, double*** %17
%273 = load i32, i32* %8
%274 = sext i32 %273 to i64
%275 = getelementptr inbounds double*, double** %272, i64 %274
%276 = load double*, double** %275
%277 = load i32, i32* %9
%278 = sext i32 %277 to i64
%279 = getelementptr inbounds double, double* %276, i64 %278
store double 0.000000e+00, double* %279
store i32 0, i32* %10
br label %280
280: ; preds = %312, %271
%281 = load i32, i32* %10
%282 = icmp slt i32 %281, 10
br i1 %282, label %283, label %315
283: ; preds = %280
%284 = load double**, double*** %11
%285 = load i32, i32* %8
%286 = sext i32 %285 to i64
%287 = getelementptr inbounds double*, double** %284, i64 %286
%288 = load double*, double** %287
%289 = load i32, i32* %10
%290 = sext i32 %289 to i64
%291 = getelementptr inbounds double, double* %288, i64 %290
%292 = load double, double* %291
%293 = load double**, double*** %12
%294 = load i32, i32* %10
%295 = sext i32 %294 to i64
%296 = getelementptr inbounds double*, double** %293, i64 %295
%297 = load double*, double** %296
%298 = load i32, i32* %9
%299 = sext i32 %298 to i64
%300 = getelementptr inbounds double, double* %297, i64 %299
%301 = load double, double* %300
%302 = load double**, double*** %17
%303 = load i32, i32* %8
%304 = sext i32 %303 to i64
%305 = getelementptr inbounds double*, double** %302, i64 %304
%306 = load double*, double** %305
%307 = load i32, i32* %9
%308 = sext i32 %307 to i64
%309 = getelementptr inbounds double, double* %306, i64 %308
%310 = load double, double* %309
%311 = call double @llvm.fmuladd.f64(double %292, double %301, double %310)
store double %311, double* %309
br label %312
312: ; preds = %283
%313 = load i32, i32* %10
%314 = add nsw i32 %313, 1
store i32 %314, i32* %10
br label %280
315: ; preds = %280
br label %316
316: ; preds = %315
%317 = load i32, i32* %9
%318 = add nsw i32 %317, 1
store i32 %318, i32* %9
br label %268
319: ; preds = %268
br label %320
320: ; preds = %319
%321 = load i32, i32* %8
%322 = add nsw i32 %321, 1
store i32 %322, i32* %8
br label %264
323: ; preds = %264
%324 = call double (...) @omp_get_wtime()
store double %324, double* %20
%325 = load double, double* %20
%326 = load double, double* %19
%327 = fsub double %325, %326
%328 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.4, i64 0, i64 0), double %327)
store i32 0, i32* %8
br label %329
329: ; preds = %384, %323
%330 = load i32, i32* %8
%331 = icmp slt i32 %330, 10
br i1 %331, label %332, label %387
332: ; preds = %329
store i32 0, i32* %9
br label %333
333: ; preds = %380, %332
%334 = load i32, i32* %9
%335 = icmp slt i32 %334, 10
br i1 %335, label %336, label %383
336: ; preds = %333
%337 = load double**, double*** %17
%338 = load i32, i32* %8
%339 = sext i32 %338 to i64
%340 = getelementptr inbounds double*, double** %337, i64 %339
%341 = load double*, double** %340
%342 = load i32, i32* %9
%343 = sext i32 %342 to i64
%344 = getelementptr inbounds double, double* %341, i64 %343
%345 = load double, double* %344
%346 = load double**, double*** %13
%347 = load i32, i32* %8
%348 = sext i32 %347 to i64
%349 = getelementptr inbounds double*, double** %346, i64 %348
%350 = load double*, double** %349
%351 = load i32, i32* %9
%352 = sext i32 %351 to i64
%353 = getelementptr inbounds double, double* %350, i64 %352
%354 = load double, double* %353
%355 = fcmp oeq double %345, %354
br i1 %355, label %356, label %357
356: ; preds = %336
br label %379
357: ; preds = %336
%358 = load double**, double*** %17
%359 = load i32, i32* %8
%360 = sext i32 %359 to i64
%361 = getelementptr inbounds double*, double** %358, i64 %360
%362 = load double*, double** %361
%363 = load i32, i32* %9
%364 = sext i32 %363 to i64
%365 = getelementptr inbounds double, double* %362, i64 %364
%366 = load double, double* %365
%367 = load double**, double*** %13
%368 = load i32, i32* %8
%369 = sext i32 %368 to i64
%370 = getelementptr inbounds double*, double** %367, i64 %369
%371 = load double*, double** %370
%372 = load i32, i32* %9
%373 = sext i32 %372 to i64
%374 = getelementptr inbounds double, double* %371, i64 %373
%375 = load double, double* %374
%376 = load i32, i32* %8
%377 = load i32, i32* %9
%378 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.5, i64 0, i64 0), double %366, double %375, i32 %376, i32 %377)
br label %379
379: ; preds = %357, %356
br label %380
380: ; preds = %379
%381 = load i32, i32* %9
%382 = add nsw i32 %381, 1
store i32 %382, i32* %9
br label %333
383: ; preds = %333
br label %384
384: ; preds = %383
%385 = load i32, i32* %8
%386 = add nsw i32 %385, 1
store i32 %386, i32* %8
br label %329
387: ; preds = %329
%388 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.6, i64 0, i64 0))
store i32 0, i32* %8
br label %389
389: ; preds = %412, %387
%390 = load i32, i32* %8
%391 = icmp slt i32 %390, 10
br i1 %391, label %392, label %415
392: ; preds = %389
store i32 0, i32* %9
br label %393
393: ; preds = %407, %392
%394 = load i32, i32* %9
%395 = icmp slt i32 %394, 10
br i1 %395, label %396, label %410
396: ; preds = %393
%397 = load double**, double*** %13
%398 = load i32, i32* %8
%399 = sext i32 %398 to i64
%400 = getelementptr inbounds double*, double** %397, i64 %399
%401 = load double*, double** %400
%402 = load i32, i32* %9
%403 = sext i32 %402 to i64
%404 = getelementptr inbounds double, double* %401, i64 %403
%405 = load double, double* %404
%406 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.7, i64 0, i64 0), double %405)
br label %407
407: ; preds = %396
%408 = load i32, i32* %9
%409 = add nsw i32 %408, 1
store i32 %409, i32* %9
br label %393
410: ; preds = %393
%411 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.8, i64 0, i64 0))
br label %412
412: ; preds = %410
%413 = load i32, i32* %8
%414 = add nsw i32 %413, 1
store i32 %414, i32* %8
br label %389
415: ; preds = %389
%416 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.9, i64 0, i64 0))
%417 = call i32 @exit(i32 0)
unreachable
}

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