#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 */
struct timezone {
  int dummy;
};
struct timeval {
  int tv_sec;
  int tv_usec;
};

/* Variables and functions */
int atoi(char *);
int /*<<< orphan*/ exit(int);
int /*<<< orphan*/ free(float **);
int /*<<< orphan*/ gettimeofday(struct timeval *, struct timezone *);
scalar_t__ malloc(int);
int /*<<< orphan*/ omp_set_num_threads(int);
int /*<<< orphan*/ printf(char *, ...);
main(int argc, char **argv) {
  int NoofRows_A, NoofCols_A, NoofRows_B, NoofCols_B, i, j, k, Noofthreads;
  float **Matrix_A, **Matrix_B, **Result, **Checkoutput, flops;
  struct timeval TimeValue_Start;
  struct timezone TimeZone_Start;
  struct timeval TimeValue_Final;
  struct timezone TimeZone_Final;
  long time_start, time_end;
  double time_overhead;
  printf("\n\t\t---------------------------------------------------------------"
         "------------");
  printf("\n\t\t Email : RarchK");
  printf("\n\t\t---------------------------------------------------------------"
         "------------");
  printf("\n\t\t Objective : Dense Matrix Computations (Floating Point "
         "Operations)\n ");
  printf("\n\t\t Matrix into Matrix Multiplication using ");
  printf("\n\t\t OpenMP one PARALLEL for directive and Private Clause;");
  printf("\n\t\t..............................................................."
         "...........\n");
  if (argc != 6) {
    printf("\t\t Very Few Arguments\n ");
    printf("\t\t Syntax : exec <Threads> <NoOfRows A> <NoOfCols A>  <NoOfRows "
           "B> <NoOfCols B>\n");
    exit(-1);
  }
  Noofthreads = atoi(argv[1]);
  if ((Noofthreads != 1) && (Noofthreads != 2) && (Noofthreads != 4) &&
      (Noofthreads != 8) && (Noofthreads != 16)) {
    printf("\n Number of threads should be 1,2,4,8 or 16 for the execution of "
           "program. \n\n");
    exit(-1);
  }
  NoofRows_A = atoi(argv[2]);
  NoofCols_A = atoi(argv[3]);
  NoofRows_B = atoi(argv[4]);
  NoofCols_B = atoi(argv[5]);
  printf("\n\t\t Threads        : %d ", Noofthreads);
  printf("\n\t\t Matrix A Size  : %d X %d ", NoofRows_A, NoofCols_A);
  printf("\n\t\t Matrix B Size  : %d X %d ", NoofRows_B, NoofCols_B);
  if (NoofRows_A <= 0 || NoofCols_A <= 0 || NoofRows_B <= 0 ||
      NoofCols_B <= 0) {
    printf("\n\t\t The NoofRows And NoofCols Should Be Of Positive Sign\n");
    exit(1);
  }
  if (NoofCols_A != NoofRows_B) {
    printf("\n\t\t Matrix Matrix Computation Is Not Possible \n");
    exit(1);
  }
  Matrix_A = (float **)malloc(sizeof(float *) * NoofRows_A);
  for (i = 0; i < NoofRows_A; i++) {
    Matrix_A[i] = (float *)malloc(sizeof(float) * NoofCols_A);
    for (j = 0; j < NoofCols_A; j++)
      Matrix_A[i][j] = i + j;
  }
  Matrix_B = (float **)malloc(sizeof(float *) * NoofRows_B);
  for (i = 0; i < NoofRows_B; i++) {
    Matrix_B[i] = (float *)malloc(sizeof(float) * NoofCols_B);
    for (j = 0; j < NoofCols_B; j++)
      Matrix_B[i][j] = i + j;
  }
  Result = (float **)malloc(sizeof(float *) * NoofRows_A);
  Checkoutput = (float **)malloc(sizeof(float *) * NoofRows_A);
  for (i = 0; i < NoofRows_A; i++) {
    Result[i] = (float *)malloc(sizeof(float) * NoofCols_B);
    Checkoutput[i] = (float *)malloc(sizeof(float) * NoofCols_B);
    for (j = 0; j < NoofCols_B; j++) {
      Result[i][j] = 0.0;
      Checkoutput[i][j] = 0.0;
    }
  }
  gettimeofday(&TimeValue_Start, &TimeZone_Start);
  omp_set_num_threads(Noofthreads);
#pragma omp parallel for private(j, k)
  for (i = 0; i < NoofRows_A; i = i + 1)
    for (j = 0; j < NoofCols_B; j = j + 1)
      for (k = 0; k < NoofCols_A; k = k + 1)
        Result[i][j] = Result[i][j] + Matrix_A[i][k] * Matrix_B[k][j];
  gettimeofday(&TimeValue_Final, &TimeZone_Final);
  time_start = TimeValue_Start.tv_sec * 1000000 + TimeValue_Start.tv_usec;
  time_end = TimeValue_Final.tv_sec * 1000000 + TimeValue_Final.tv_usec;
  time_overhead = (time_end - time_start) / 1000000.0;
  for (i = 0; i < NoofRows_A; i = i + 1)
    for (j = 0; j < NoofCols_B; j = j + 1)
      for (k = 0; k < NoofCols_A; k = k + 1)
        Checkoutput[i][j] = Checkoutput[i][j] + Matrix_A[i][k] * Matrix_B[k][j];
  for (i = 0; i < NoofRows_A; i = i + 1)
    for (j = 0; j < NoofCols_B; j = j + 1)
      if (Checkoutput[i][j] == Result[i][j])
        continue;
      else {
        printf("\n\t\t There Is A Difference In Parallel Calculation \n");
        exit(1);
      }
  printf("\n\n\t\t Matrix into Matrix Multiplication using Parallel for "
         "directive......Done \n");
  printf("\n\t\t Time in Seconds (T)        : %lf Seconds \n", time_overhead);
  printf("\n\t\t   ( T represents the Time taken for computation )");
  printf("\n\t\t..............................................................."
         "...........\n");
  free(Matrix_A);
  free(Matrix_B);
  free(Result);
  free(Checkoutput);
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
lea    0xe78(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xeb9(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xe5c(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xeb0(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xeea(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xf09(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xf35(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
cmpl   $0x6,-0x8(%rbp)
je     121b <main+0xab>
lea    0xf6c(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xf76(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    $0xffffffff,%edi
call   1090 <exit@plt>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rdi
call   1080 <atoi@plt>
mov    %eax,-0x30(%rbp)
cmpl   $0x1,-0x30(%rbp)
je     1275 <main+0x105>
cmpl   $0x2,-0x30(%rbp)
je     1275 <main+0x105>
cmpl   $0x4,-0x30(%rbp)
je     1275 <main+0x105>
cmpl   $0x8,-0x30(%rbp)
je     1275 <main+0x105>
cmpl   $0x10,-0x30(%rbp)
je     1275 <main+0x105>
lea    0xf6d(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    $0xffffffff,%edi
call   1090 <exit@plt>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rdi
call   1080 <atoi@plt>
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rdi
call   1080 <atoi@plt>
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
mov    0x20(%rax),%rdi
call   1080 <atoi@plt>
mov    %eax,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
mov    0x28(%rax),%rdi
call   1080 <atoi@plt>
mov    %eax,-0x20(%rbp)
mov    -0x30(%rbp),%esi
lea    0xf5f(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0xf64(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x1c(%rbp),%esi
mov    -0x20(%rbp),%edx
lea    0xf6e(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
cmpl   $0x0,-0x14(%rbp)
jle    1316 <main+0x1a6>
cmpl   $0x0,-0x18(%rbp)
jle    1316 <main+0x1a6>
cmpl   $0x0,-0x1c(%rbp)
jle    1316 <main+0x1a6>
cmpl   $0x0,-0x20(%rbp)
jg     132e <main+0x1be>
lea    0xf56(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    $0x1,%edi
call   1090 <exit@plt>
mov    -0x18(%rbp),%eax
cmp    -0x1c(%rbp),%eax
je     1352 <main+0x1e2>
lea    0xf6c(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    $0x1,%edi
call   1090 <exit@plt>
movslq -0x14(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    13e9 <main+0x279>
movslq -0x18(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,%rdx
mov    -0x38(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    13d6 <main+0x266>
mov    -0x24(%rbp),%eax
add    -0x28(%rbp),%eax
cvtsi2ss %eax,%xmm0
mov    -0x38(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    139d <main+0x22d>
jmp    13db <main+0x26b>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    136c <main+0x1fc>
movslq -0x1c(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1480 <main+0x310>
movslq -0x20(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,%rdx
mov    -0x40(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    146d <main+0x2fd>
mov    -0x24(%rbp),%eax
add    -0x28(%rbp),%eax
cvtsi2ss %eax,%xmm0
mov    -0x40(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1434 <main+0x2c4>
jmp    1472 <main+0x302>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1403 <main+0x293>
movslq -0x14(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x48(%rbp)
movslq -0x14(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x50(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1559 <main+0x3e9>
movslq -0x20(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,%rdx
mov    -0x48(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
movslq -0x20(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,%rdx
mov    -0x50(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1546 <main+0x3d6>
mov    -0x48(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x50(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    14fc <main+0x38c>
jmp    154b <main+0x3db>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    14ad <main+0x33d>
lea    -0x60(%rbp),%rdi
lea    -0x68(%rbp),%rsi
call   1050 <gettimeofday@plt>
mov    -0x30(%rbp),%edi
call   1070 <omp_set_num_threads@plt>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1637 <main+0x4c7>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1624 <main+0x4b4>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1611 <main+0x4a1>
mov    -0x48(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x38(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    159b <main+0x42b>
jmp    1616 <main+0x4a6>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1588 <main+0x418>
jmp    1629 <main+0x4b9>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1575 <main+0x405>
lea    -0x70(%rbp),%rdi
lea    -0x78(%rbp),%rsi
call   1050 <gettimeofday@plt>
imul   $0xf4240,-0x60(%rbp),%eax
add    -0x5c(%rbp),%eax
cltq
mov    %rax,-0x80(%rbp)
imul   $0xf4240,-0x70(%rbp),%eax
add    -0x6c(%rbp),%eax
cltq
mov    %rax,-0x88(%rbp)
mov    -0x88(%rbp),%rax
sub    -0x80(%rbp),%rax
cvtsi2sd %rax,%xmm0
movsd  0x981(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1754 <main+0x5e4>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1741 <main+0x5d1>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    172e <main+0x5be>
mov    -0x50(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x38(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x50(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    16b8 <main+0x548>
jmp    1733 <main+0x5c3>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    16a5 <main+0x535>
jmp    1746 <main+0x5d6>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1692 <main+0x522>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    17ed <main+0x67d>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    17da <main+0x66a>
mov    -0x50(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
ucomiss (%rax,%rcx,4),%xmm0
jne    17b4 <main+0x644>
jp     17b4 <main+0x644>
jmp    17cc <main+0x65c>
lea    0xb22(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    $0x1,%edi
call   1090 <exit@plt>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    176e <main+0x5fe>
jmp    17df <main+0x66f>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    175b <main+0x5eb>
lea    0xb1d(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movsd  -0x90(%rbp),%xmm0
ff
lea    0xb57(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
lea    0xb78(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x8f3(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
mov    -0x4(%rbp),%eax
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x98,%rsp
mov    %rsi,%rbx
mov    %edi,%r14d
lea    0xe9a(%rip),%rbp
mov    %rbp,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0xed8(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %rbp,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0xed3(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0xf0d(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0xf2c(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0x1079(%rip),%rdi
call   1040 <puts@plt>
cmp    $0x6,%r14d
jne    1a8b <main+0x90b>
mov    0x8(%rbx),%rdi
call   1090 <atoi@plt>
cmp    $0x10,%eax
ja     1ac1 <main+0x941>
mov    %eax,%r15d
mov    $0x10116,%eax
bt     %r15d,%eax
jae    1ac1 <main+0x941>
mov    0x10(%rbx),%rdi
call   1090 <atoi@plt>
mov    %eax,%r14d
mov    0x18(%rbx),%rdi
call   1090 <atoi@plt>
mov    %eax,%r12d
mov    0x20(%rbx),%rdi
call   1090 <atoi@plt>
mov    %eax,%ebp
mov    0x28(%rbx),%rdi
call   1090 <atoi@plt>
mov    %eax,%ebx
lea    0xf08(%rip),%rdi
mov    %r15d,%esi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0xf10(%rip),%rdi
mov    %r14d,%esi
mov    %r12d,%edx
xor    %eax,%eax
call   1050 <printf@plt>
lea    0xf1a(%rip),%rdi
mov    %ebp,%esi
mov    %ebx,%edx
xor    %eax,%eax
call   1050 <printf@plt>
test   %r14d,%r14d
jle    1aaf <main+0x92f>
test   %r12d,%r12d
jle    1aaf <main+0x92f>
test   %ebp,%ebp
jle    1aaf <main+0x92f>
test   %ebx,%ebx
jle    1aaf <main+0x92f>
mov    %r15d,0x44(%rsp)
mov    %rbx,0x18(%rsp)
cmp    %ebp,%r12d
jne    1ab8 <main+0x938>
lea    0x0(,%r14,8),%edi
mov    %edi,0x28(%rsp)
call   1070 <malloc@plt>
mov    %rax,0x30(%rsp)
lea    0x0(,%r12,4),%r13d
mov    %r14d,%eax
mov    %rax,0x8(%rsp)
mov    %r12d,%r14d
mov    %r14d,%r15d
and    $0xfffffff8,%r15d
lea    0x0(,%r14,4),%rbx
and    $0xffffffffffffffe0,%rbx
xor    %ebp,%ebp
jmp    130f <main+0x18f>
xchg   %ax,%ax
add    $0x1,%rbp
cmp    0x8(%rsp),%rbp
je     13ed <main+0x26d>
mov    %r13d,%edi
call   1070 <malloc@plt>
mov    0x30(%rsp),%rcx
mov    %rax,(%rcx,%rbp,8)
cmp    $0x8,%r12d
jae    1330 <main+0x1b0>
xor    %ecx,%ecx
jmp    13d0 <main+0x250>
nopl   (%rax)
movq   %rbp,%xmm0
pshufd $0x44,%xmm0,%xmm0
lea    0x4(%rbp),%rcx
movq   %rcx,%xmm1
pshufd $0x44,%xmm1,%xmm1
xor    %ecx,%ecx
movdqa 0xcbe(%rip),%xmm2
movdqa 0xca6(%rip),%xmm3
movdqa 0xcbe(%rip),%xmm7
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqa %xmm2,%xmm4
paddq  %xmm0,%xmm4
movdqa %xmm3,%xmm5
paddq  %xmm0,%xmm5
shufps $0x88,%xmm5,%xmm4
movdqa %xmm1,%xmm5
paddq  %xmm2,%xmm5
movdqa %xmm1,%xmm6
paddq  %xmm3,%xmm6
shufps $0x88,%xmm6,%xmm5
cvtdq2ps %xmm4,%xmm4
cvtdq2ps %xmm5,%xmm5
movups %xmm4,(%rax,%rcx,1)
movups %xmm5,0x10(%rax,%rcx,1)
paddq  %xmm7,%xmm2
paddq  %xmm7,%xmm3
add    $0x20,%rcx
cmp    %rcx,%rbx
jne    1370 <main+0x1f0>
mov    %r15,%rcx
cmp    %r14,%r15
je     1300 <main+0x180>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    (%rcx,%rbp,1),%edx
xorps  %xmm0,%xmm0
cvtsi2ss %edx,%xmm0
movss  %xmm0,(%rax,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%r14
jne    13d0 <main+0x250>
jmp    1300 <main+0x180>
lea    0x0(,%r12,8),%edi
call   1070 <malloc@plt>
mov    %rax,%rbx
mov    0x18(%rsp),%rsi
mov    %esi,%r13d
test   %r12d,%r12d
jle    152e <main+0x3ae>
lea    0x0(,%rsi,4),%eax
mov    %eax,0x20(%rsp)
mov    %r13d,%eax
and    $0xfffffff8,%eax
mov    %rax,0x10(%rsp)
lea    0x0(,%r13,4),%rbp
and    $0xffffffffffffffe0,%rbp
xor    %r15d,%r15d
jmp    144d <main+0x2cd>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r15
cmp    %r14,%r15
je     152e <main+0x3ae>
mov    0x20(%rsp),%edi
call   1070 <malloc@plt>
mov    0x18(%rsp),%rsi
mov    %rax,(%rbx,%r15,8)
test   %esi,%esi
jle    1440 <main+0x2c0>
cmp    $0x8,%esi
jae    1470 <main+0x2f0>
xor    %ecx,%ecx
jmp    1510 <main+0x390>
nop
movq   %r15,%xmm0
pshufd $0x44,%xmm0,%xmm0
lea    0x4(%r15),%rcx
movq   %rcx,%xmm1
pshufd $0x44,%xmm1,%xmm1
xor    %ecx,%ecx
movdqa 0xb7e(%rip),%xmm2
movdqa 0xb66(%rip),%xmm3
movdqa 0xb7e(%rip),%xmm7
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqa %xmm2,%xmm4
paddq  %xmm0,%xmm4
movdqa %xmm3,%xmm5
paddq  %xmm0,%xmm5
shufps $0x88,%xmm5,%xmm4
movdqa %xmm1,%xmm5
paddq  %xmm2,%xmm5
movdqa %xmm1,%xmm6
paddq  %xmm3,%xmm6
shufps $0x88,%xmm6,%xmm5
cvtdq2ps %xmm4,%xmm4
cvtdq2ps %xmm5,%xmm5
movups %xmm4,(%rax,%rcx,1)
movups %xmm5,0x10(%rax,%rcx,1)
paddq  %xmm7,%xmm2
paddq  %xmm7,%xmm3
add    $0x20,%rcx
cmp    %rcx,%rbp
jne    14b0 <main+0x330>
mov    0x10(%rsp),%rdx
mov    %rdx,%rcx
cmp    %r13,%rdx
je     1440 <main+0x2c0>
nopl   0x0(%rax)
lea    (%r15,%rcx,1),%edx
xorps  %xmm0,%xmm0
cvtsi2ss %edx,%xmm0
movss  %xmm0,(%rax,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%r13
jne    1510 <main+0x390>
jmp    1440 <main+0x2c0>
mov    %r12,0x58(%rsp)
mov    0x28(%rsp),%ebp
mov    %ebp,%edi
mov    %rsi,%r15
call   1070 <malloc@plt>
mov    %rax,0x10(%rsp)
mov    %ebp,%edi
call   1070 <malloc@plt>
mov    %rax,0x20(%rsp)
lea    0x0(,%r15,4),%eax
mov    %eax,0x28(%rsp)
mov    %r13d,%eax
and    $0xfffffff8,%eax
mov    %rax,0x78(%rsp)
add    $0xfffffffffffffff8,%rax
mov    %rax,0x70(%rsp)
shr    $0x3,%rax
add    $0x1,%rax
mov    %eax,%ecx
and    $0x3,%ecx
and    $0xfffffffffffffffc,%rax
mov    %rax,0x60(%rsp)
mov    %r13d,%r8d
and    $0x3,%r8d
mov    %rcx,0x68(%rsp)
mov    %rcx,%rbp
shl    $0x5,%rbp
xor    %r12d,%r12d
mov    %rbp,0x38(%rsp)
mov    %r8,0x80(%rsp)
mov    0x10(%rsp),%r15
jmp    15cf <main+0x44f>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r12
cmp    0x8(%rsp),%r12
je     1795 <main+0x615>
mov    0x28(%rsp),%ebp
mov    %ebp,%edi
call   1070 <malloc@plt>
mov    %rax,(%r15,%r12,8)
mov    %ebp,%edi
call   1070 <malloc@plt>
pxor   %xmm0,%xmm0
mov    0x38(%rsp),%rbp
mov    0x80(%rsp),%r8
mov    0x20(%rsp),%rdx
mov    %rax,(%rdx,%r12,8)
mov    0x18(%rsp),%rdx
test   %edx,%edx
jle    15c0 <main+0x440>
mov    (%r15,%r12,8),%rcx
cmp    $0x8,%edx
jb     162b <main+0x4ab>
lea    (%rax,%r13,4),%rdx
cmp    %rdx,%rcx
jae    16bc <main+0x53c>
lea    (%rcx,%r13,4),%rdx
cmp    %rdx,%rax
jae    16bc <main+0x53c>
xor    %edx,%edx
mov    %rdx,%rsi
not    %rsi
add    %r13,%rsi
test   %r8,%r8
je     1658 <main+0x4d8>
mov    %r8,%rdi
xchg   %ax,%ax
movl   $0x0,(%rcx,%rdx,4)
movl   $0x0,(%rax,%rdx,4)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rdi
jne    1640 <main+0x4c0>
cmp    $0x3,%rsi
jb     15c0 <main+0x440>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movl   $0x0,(%rcx,%rdx,4)
movl   $0x0,(%rax,%rdx,4)
movl   $0x0,0x4(%rcx,%rdx,4)
movl   $0x0,0x4(%rax,%rdx,4)
movl   $0x0,0x8(%rcx,%rdx,4)
movl   $0x0,0x8(%rax,%rdx,4)
movl   $0x0,0xc(%rcx,%rdx,4)
movl   $0x0,0xc(%rax,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%r13
jne    1670 <main+0x4f0>
jmp    15c0 <main+0x440>
cmpq   $0x18,0x70(%rsp)
jae    16c8 <main+0x548>
xor    %edx,%edx
jmp    1738 <main+0x5b8>
mov    0x60(%rsp),%rsi
xor    %edx,%edx
nop
movdqu %xmm0,(%rcx,%rdx,4)
movdqu %xmm0,0x10(%rcx,%rdx,4)
movdqu %xmm0,(%rax,%rdx,4)
movdqu %xmm0,0x10(%rax,%rdx,4)
movdqu %xmm0,0x20(%rcx,%rdx,4)
movdqu %xmm0,0x30(%rcx,%rdx,4)
movdqu %xmm0,0x20(%rax,%rdx,4)
movdqu %xmm0,0x30(%rax,%rdx,4)
movdqu %xmm0,0x40(%rcx,%rdx,4)
movdqu %xmm0,0x50(%rcx,%rdx,4)
movdqu %xmm0,0x40(%rax,%rdx,4)
movdqu %xmm0,0x50(%rax,%rdx,4)
movdqu %xmm0,0x60(%rcx,%rdx,4)
movdqu %xmm0,0x70(%rcx,%rdx,4)
movdqu %xmm0,0x60(%rax,%rdx,4)
movdqu %xmm0,0x70(%rax,%rdx,4)
add    $0x20,%rdx
add    $0xfffffffffffffffc,%rsi
jne    16d0 <main+0x550>
cmpq   $0x0,0x68(%rsp)
je     177f <main+0x5ff>
lea    (%rax,%rdx,4),%rsi
add    $0x10,%rsi
lea    (%rcx,%rdx,4),%rdx
add    $0x10,%rdx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqu %xmm0,-0x10(%rdx,%rdi,1)
movdqu %xmm0,(%rdx,%rdi,1)
movdqu %xmm0,-0x10(%rsi,%rdi,1)
movdqu %xmm0,(%rsi,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rbp
jne    1760 <main+0x5e0>
mov    0x78(%rsp),%rsi
mov    %rsi,%rdx
cmp    %r13,%rsi
je     15c0 <main+0x440>
jmp    162d <main+0x4ad>
lea    0x50(%rsp),%rdi
lea    0x90(%rsp),%rsi
call   1060 <gettimeofday@plt>
mov    0x44(%rsp),%edi
call   1080 <omp_set_num_threads@plt>
lea    -0x1(%r14),%r15
mov    %r14d,%eax
and    $0xfffffffe,%eax
xor    %r8d,%r8d
mov    0x18(%rsp),%r9
mov    0x10(%rsp),%r10
mov    0x58(%rsp),%r12
jmp    17df <main+0x65f>
xchg   %ax,%ax
add    $0x1,%r8
cmp    0x8(%rsp),%r8
je     187b <main+0x6fb>
test   %r9d,%r9d
jle    17d0 <main+0x650>
xor    %edx,%edx
jmp    17f9 <main+0x679>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rdx
cmp    %r13,%rdx
je     17d0 <main+0x650>
test   %r12d,%r12d
jle    17f0 <main+0x670>
mov    (%r10,%r8,8),%rsi
mov    0x30(%rsp),%rcx
mov    (%rcx,%r8,8),%rdi
movss  (%rsi,%rdx,4),%xmm0
xor    %ebp,%ebp
test   %r15,%r15
je     1859 <main+0x6d9>
nopw   0x0(%rax,%rax,1)
movss  (%rdi,%rbp,4),%xmm1
mov    (%rbx,%rbp,8),%rcx
mulss  (%rcx,%rdx,4),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%rsi,%rdx,4)
movss  0x4(%rdi,%rbp,4),%xmm0
mov    0x8(%rbx,%rbp,8),%rcx
mulss  (%rcx,%rdx,4),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rsi,%rdx,4)
add    $0x2,%rbp
cmp    %rbp,%rax
jne    1820 <main+0x6a0>
test   $0x1,%r14b
je     17f0 <main+0x670>
movss  (%rdi,%rbp,4),%xmm1
mov    (%rbx,%rbp,8),%rcx
mulss  (%rcx,%rdx,4),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%rsi,%rdx,4)
jmp    17f0 <main+0x670>
lea    0x48(%rsp),%rdi
lea    0x88(%rsp),%rsi
call   1060 <gettimeofday@plt>
movslq 0x50(%rsp),%rax
mov    %rax,0x38(%rsp)
movslq 0x54(%rsp),%rax
mov    %rax,0x28(%rsp)
movslq 0x48(%rsp),%r11
movslq 0x4c(%rsp),%r10
mov    %r14d,%edi
and    $0xfffffffe,%edi
xor    %r9d,%r9d
jmp    18cf <main+0x74f>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r9
cmp    0x8(%rsp),%r9
je     196c <main+0x7ec>
cmpl   $0x0,0x18(%rsp)
jle    18c0 <main+0x740>
xor    %ecx,%ecx
jmp    18e9 <main+0x769>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rcx
cmp    %r13,%rcx
je     18c0 <main+0x740>
test   %r12d,%r12d
jle    18e0 <main+0x760>
mov    0x20(%rsp),%rax
mov    (%rax,%r9,8),%rdx
mov    0x30(%rsp),%rax
mov    (%rax,%r9,8),%rsi
movss  (%rdx,%rcx,4),%xmm0
xor    %ebp,%ebp
test   %r15,%r15
je     194a <main+0x7ca>
nopl   0x0(%rax)
movss  (%rsi,%rbp,4),%xmm1
mov    (%rbx,%rbp,8),%r8
mulss  (%r8,%rcx,4),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%rdx,%rcx,4)
movss  0x4(%rsi,%rbp,4),%xmm0
mov    0x8(%rbx,%rbp,8),%rax
mulss  (%rax,%rcx,4),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rdx,%rcx,4)
add    $0x2,%rbp
cmp    %rbp,%rdi
jne    1910 <main+0x790>
test   $0x1,%r14b
je     18e0 <main+0x760>
movss  (%rsi,%rbp,4),%xmm1
mov    (%rbx,%rbp,8),%rax
mulss  (%rax,%rcx,4),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%rdx,%rcx,4)
jmp    18e0 <main+0x760>
xor    %eax,%eax
mov    0x18(%rsp),%rdi
jmp    198b <main+0x80b>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rax
cmp    0x8(%rsp),%rax
je     19d0 <main+0x850>
test   %edi,%edi
jle    1980 <main+0x800>
mov    0x20(%rsp),%rcx
mov    (%rcx,%rax,8),%rcx
mov    0x10(%rsp),%rdx
mov    (%rdx,%rax,8),%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  (%rcx,%rsi,4),%xmm0
ucomiss (%rdx,%rsi,4),%xmm0
jne    1a75 <main+0x8f5>
jp     1a75 <main+0x8f5>
add    $0x1,%rsi
cmp    %rsi,%r13
jne    19b0 <main+0x830>
jmp    1980 <main+0x800>
imul   $0xf4240,%r11,%rax
add    %r10,%rax
imul   $0xf4240,0x38(%rsp),%rcx
add    0x28(%rsp),%rcx
sub    %rcx,%rax
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
divsd  0x635(%rip),%xmm0
movsd  %xmm0,0x8(%rsp)
lea    0x813(%rip),%rdi
call   1040 <puts@plt>
lea    0x7a2(%rip),%rdi
movsd  0x8(%rsp),%xmm0
mov    $0x1,%al
call   1050 <printf@plt>
lea    0x7bd(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0x834(%rip),%rdi
call   1040 <puts@plt>
mov    0x30(%rsp),%rdi
call   1030 <free@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    0x10(%rsp),%rdi
call   1030 <free@plt>
mov    0x20(%rsp),%rdi
call   1030 <free@plt>
xor    %eax,%eax
add    $0x98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0x83c(%rip),%rdi
call   1040 <puts@plt>
mov    $0x1,%edi
call   10a0 <exit@plt>
lea    0x6b7(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0x8ff(%rip),%rdi
call   1040 <puts@plt>
mov    $0xffffffff,%edi
call   10a0 <exit@plt>
lea    0x864(%rip),%rdi
jmp    1a7c <main+0x8fc>
lea    0x82c(%rip),%rdi
jmp    1a7c <main+0x8fc>
lea    0x88b(%rip),%rdi
jmp    1aa0 <main+0x920>

LLVM IR (-O0):
%struct.timeval = type { i32, i32 }
%struct.timezone = type { i32 }
@.str = [79 x i8] c"\0A\09\09---------------------------------------------------------------------------\00"
@.str.1 = [19 x i8] c"\0A\09\09 Email : RarchK\00"
@.str.2 = [72 x i8] c"\0A\09\09 Objective : Dense Matrix Computations (Floating Point Operations)\0A \00"
@.str.3 = [45 x i8] c"\0A\09\09 Matrix into Matrix Multiplication using \00"
@.str.4 = [58 x i8] c"\0A\09\09 OpenMP one PARALLEL for directive and Private Clause;\00"
@.str.5 = [79 x i8] c"\0A\09\09..........................................................................\0A\00"
@.str.6 = [24 x i8] c"\09\09 Very Few Arguments\0A \00"
@.str.7 = [81 x i8] c"\09\09 Syntax : exec <Threads> <NoOfRows A> <NoOfCols A> <NoOfRows B> <NoOfCols B>\0A\00"
@.str.8 = [77 x i8] c"\0A Number of threads should be 1,2,4,8 or 16 for the execution of program. \0A\0A\00"
@.str.9 = [25 x i8] c"\0A\09\09 Threads : %d \00"
@.str.10 = [30 x i8] c"\0A\09\09 Matrix A Size : %d X %d \00"
@.str.11 = [30 x i8] c"\0A\09\09 Matrix B Size : %d X %d \00"
@.str.12 = [58 x i8] c"\0A\09\09 The NoofRows And NoofCols Should Be Of Positive Sign\0A\00"
@.str.13 = [48 x i8] c"\0A\09\09 Matrix Matrix Computation Is Not Possible \0A\00"
@.str.14 = [52 x i8] c"\0A\09\09 There Is A Difference In Parallel Calculation \0A\00"
@.str.15 = [80 x i8] c"\0A\0A\09\09 Matrix into Matrix Multiplication using Parallel for directive......Done \0A\00"
@.str.16 = [47 x i8] c"\0A\09\09 Time in Seconds (T) : %lf Seconds \0A\00"
@.str.17 = [54 x i8] c"\0A\09\09 ( T represents the Time taken for computation )\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 i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca float**
%15 = alloca float**
%16 = alloca float**
%17 = alloca float**
%18 = alloca float
%19 = alloca %struct.timeval
%20 = alloca %struct.timezone
%21 = alloca %struct.timeval
%22 = alloca %struct.timezone
%23 = alloca i64
%24 = alloca i64
%25 = alloca double
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
%26 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([79 x i8], [79 x i8]* @.str, i64 0, i64 0))
%27 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.1, i64 0, i64 0))
%28 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([79 x i8], [79 x i8]* @.str, i64 0, i64 0))
%29 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([72 x i8], [72 x i8]* @.str.2, i64 0, i64 0))
%30 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str.3, i64 0, i64 0))
%31 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([58 x i8], [58 x i8]* @.str.4, i64 0, i64 0))
%32 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([79 x i8], [79 x i8]* @.str.5, i64 0, i64 0))
%33 = load i32, i32* %4
%34 = icmp ne i32 %33, 6
br i1 %34, label %35, label %39
35: ; preds = %2
%36 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.6, i64 0, i64 0))
%37 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([81 x i8], [81 x i8]* @.str.7, i64 0, i64 0))
%38 = call i32 @exit(i32 -1)
unreachable
39: ; preds = %2
%40 = load i8**, i8*** %5
%41 = getelementptr inbounds i8*, i8** %40, i64 1
%42 = load i8*, i8** %41
%43 = call i32 @atoi(i8* %42)
store i32 %43, i32* %13
%44 = load i32, i32* %13
%45 = icmp ne i32 %44, 1
br i1 %45, label %46, label %61
46: ; preds = %39
%47 = load i32, i32* %13
%48 = icmp ne i32 %47, 2
br i1 %48, label %49, label %61
49: ; preds = %46
%50 = load i32, i32* %13
%51 = icmp ne i32 %50, 4
br i1 %51, label %52, label %61
52: ; preds = %49
%53 = load i32, i32* %13
%54 = icmp ne i32 %53, 8
br i1 %54, label %55, label %61
55: ; preds = %52
%56 = load i32, i32* %13
%57 = icmp ne i32 %56, 16
br i1 %57, label %58, label %61
58: ; preds = %55
%59 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([77 x i8], [77 x i8]* @.str.8, i64 0, i64 0))
%60 = call i32 @exit(i32 -1)
unreachable
61: ; preds = %55, %52, %49, %46, %39
%62 = load i8**, i8*** %5
%63 = getelementptr inbounds i8*, i8** %62, i64 2
%64 = load i8*, i8** %63
%65 = call i32 @atoi(i8* %64)
store i32 %65, i32* %6
%66 = load i8**, i8*** %5
%67 = getelementptr inbounds i8*, i8** %66, i64 3
%68 = load i8*, i8** %67
%69 = call i32 @atoi(i8* %68)
store i32 %69, i32* %7
%70 = load i8**, i8*** %5
%71 = getelementptr inbounds i8*, i8** %70, i64 4
%72 = load i8*, i8** %71
%73 = call i32 @atoi(i8* %72)
store i32 %73, i32* %8
%74 = load i8**, i8*** %5
%75 = getelementptr inbounds i8*, i8** %74, i64 5
%76 = load i8*, i8** %75
%77 = call i32 @atoi(i8* %76)
store i32 %77, i32* %9
%78 = load i32, i32* %13
%79 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.9, i64 0, i64 0), i32 %78)
%80 = load i32, i32* %6
%81 = load i32, i32* %7
%82 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.10, i64 0, i64 0), i32 %80, i32 %81)
%83 = load i32, i32* %8
%84 = load i32, i32* %9
%85 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.11, i64 0, i64 0), i32 %83, i32 %84)
%86 = load i32, i32* %6
%87 = icmp sle i32 %86, 0
br i1 %87, label %97, label %88
88: ; preds = %61
%89 = load i32, i32* %7
%90 = icmp sle i32 %89, 0
br i1 %90, label %97, label %91
91: ; preds = %88
%92 = load i32, i32* %8
%93 = icmp sle i32 %92, 0
br i1 %93, label %97, label %94
94: ; preds = %91
%95 = load i32, i32* %9
%96 = icmp sle i32 %95, 0
br i1 %96, label %97, label %100
97: ; preds = %94, %91, %88, %61
%98 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([58 x i8], [58 x i8]* @.str.12, i64 0, i64 0))
%99 = call i32 @exit(i32 1)
unreachable
100: ; preds = %94
%101 = load i32, i32* %7
%102 = load i32, i32* %8
%103 = icmp ne i32 %101, %102
br i1 %103, label %104, label %107
104: ; preds = %100
%105 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([48 x i8], [48 x i8]* @.str.13, i64 0, i64 0))
%106 = call i32 @exit(i32 1)
unreachable
107: ; preds = %100
%108 = load i32, i32* %6
%109 = sext i32 %108 to i64
%110 = mul i64 8, %109
%111 = trunc i64 %110 to i32
%112 = call i64 @malloc(i32 %111)
%113 = inttoptr i64 %112 to float**
store float** %113, float*** %14
store i32 0, i32* %10
br label %114
114: ; preds = %150, %107
%115 = load i32, i32* %10
%116 = load i32, i32* %6
%117 = icmp slt i32 %115, %116
br i1 %117, label %118, label %153
118: ; preds = %114
%119 = load i32, i32* %7
%120 = sext i32 %119 to i64
%121 = mul i64 4, %120
%122 = trunc i64 %121 to i32
%123 = call i64 @malloc(i32 %122)
%124 = inttoptr i64 %123 to float*
%125 = load float**, float*** %14
%126 = load i32, i32* %10
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds float*, float** %125, i64 %127
store float* %124, float** %128
store i32 0, i32* %11
br label %129
129: ; preds = %146, %118
%130 = load i32, i32* %11
%131 = load i32, i32* %7
%132 = icmp slt i32 %130, %131
br i1 %132, label %133, label %149
133: ; preds = %129
%134 = load i32, i32* %10
%135 = load i32, i32* %11
%136 = add nsw i32 %134, %135
%137 = sitofp i32 %136 to float
%138 = load float**, float*** %14
%139 = load i32, i32* %10
%140 = sext i32 %139 to i64
%141 = getelementptr inbounds float*, float** %138, i64 %140
%142 = load float*, float** %141
%143 = load i32, i32* %11
%144 = sext i32 %143 to i64
%145 = getelementptr inbounds float, float* %142, i64 %144
store float %137, float* %145
br label %146
146: ; preds = %133
%147 = load i32, i32* %11
%148 = add nsw i32 %147, 1
store i32 %148, i32* %11
br label %129
149: ; preds = %129
br label %150
150: ; preds = %149
%151 = load i32, i32* %10
%152 = add nsw i32 %151, 1
store i32 %152, i32* %10
br label %114
153: ; preds = %114
%154 = load i32, i32* %8
%155 = sext i32 %154 to i64
%156 = mul i64 8, %155
%157 = trunc i64 %156 to i32
%158 = call i64 @malloc(i32 %157)
%159 = inttoptr i64 %158 to float**
store float** %159, float*** %15
store i32 0, i32* %10
br label %160
160: ; preds = %196, %153
%161 = load i32, i32* %10
%162 = load i32, i32* %8
%163 = icmp slt i32 %161, %162
br i1 %163, label %164, label %199
164: ; preds = %160
%165 = load i32, i32* %9
%166 = sext i32 %165 to i64
%167 = mul i64 4, %166
%168 = trunc i64 %167 to i32
%169 = call i64 @malloc(i32 %168)
%170 = inttoptr i64 %169 to float*
%171 = load float**, float*** %15
%172 = load i32, i32* %10
%173 = sext i32 %172 to i64
%174 = getelementptr inbounds float*, float** %171, i64 %173
store float* %170, float** %174
store i32 0, i32* %11
br label %175
175: ; preds = %192, %164
%176 = load i32, i32* %11
%177 = load i32, i32* %9
%178 = icmp slt i32 %176, %177
br i1 %178, label %179, label %195
179: ; preds = %175
%180 = load i32, i32* %10
%181 = load i32, i32* %11
%182 = add nsw i32 %180, %181
%183 = sitofp i32 %182 to float
%184 = load float**, float*** %15
%185 = load i32, i32* %10
%186 = sext i32 %185 to i64
%187 = getelementptr inbounds float*, float** %184, i64 %186
%188 = load float*, float** %187
%189 = load i32, i32* %11
%190 = sext i32 %189 to i64
%191 = getelementptr inbounds float, float* %188, i64 %190
store float %183, float* %191
br label %192
192: ; preds = %179
%193 = load i32, i32* %11
%194 = add nsw i32 %193, 1
store i32 %194, i32* %11
br label %175
195: ; preds = %175
br label %196
196: ; preds = %195
%197 = load i32, i32* %10
%198 = add nsw i32 %197, 1
store i32 %198, i32* %10
br label %160
199: ; preds = %160
%200 = load i32, i32* %6
%201 = sext i32 %200 to i64
%202 = mul i64 8, %201
%203 = trunc i64 %202 to i32
%204 = call i64 @malloc(i32 %203)
%205 = inttoptr i64 %204 to float**
store float** %205, float*** %16
%206 = load i32, i32* %6
%207 = sext i32 %206 to i64
%208 = mul i64 8, %207
%209 = trunc i64 %208 to i32
%210 = call i64 @malloc(i32 %209)
%211 = inttoptr i64 %210 to float**
store float** %211, float*** %17
store i32 0, i32* %10
br label %212
212: ; preds = %262, %199
%213 = load i32, i32* %10
%214 = load i32, i32* %6
%215 = icmp slt i32 %213, %214
br i1 %215, label %216, label %265
216: ; preds = %212
%217 = load i32, i32* %9
%218 = sext i32 %217 to i64
%219 = mul i64 4, %218
%220 = trunc i64 %219 to i32
%221 = call i64 @malloc(i32 %220)
%222 = inttoptr i64 %221 to float*
%223 = load float**, float*** %16
%224 = load i32, i32* %10
%225 = sext i32 %224 to i64
%226 = getelementptr inbounds float*, float** %223, i64 %225
store float* %222, float** %226
%227 = load i32, i32* %9
%228 = sext i32 %227 to i64
%229 = mul i64 4, %228
%230 = trunc i64 %229 to i32
%231 = call i64 @malloc(i32 %230)
%232 = inttoptr i64 %231 to float*
%233 = load float**, float*** %17
%234 = load i32, i32* %10
%235 = sext i32 %234 to i64
%236 = getelementptr inbounds float*, float** %233, i64 %235
store float* %232, float** %236
store i32 0, i32* %11
br label %237
237: ; preds = %258, %216
%238 = load i32, i32* %11
%239 = load i32, i32* %9
%240 = icmp slt i32 %238, %239
br i1 %240, label %241, label %261
241: ; preds = %237
%242 = load float**, float*** %16
%243 = load i32, i32* %10
%244 = sext i32 %243 to i64
%245 = getelementptr inbounds float*, float** %242, i64 %244
%246 = load float*, float** %245
%247 = load i32, i32* %11
%248 = sext i32 %247 to i64
%249 = getelementptr inbounds float, float* %246, i64 %248
store float 0.000000e+00, float* %249
%250 = load float**, float*** %17
%251 = load i32, i32* %10
%252 = sext i32 %251 to i64
%253 = getelementptr inbounds float*, float** %250, i64 %252
%254 = load float*, float** %253
%255 = load i32, i32* %11
%256 = sext i32 %255 to i64
%257 = getelementptr inbounds float, float* %254, i64 %256
store float 0.000000e+00, float* %257
br label %258
258: ; preds = %241
%259 = load i32, i32* %11
%260 = add nsw i32 %259, 1
store i32 %260, i32* %11
br label %237
261: ; preds = %237
br label %262
262: ; preds = %261
%263 = load i32, i32* %10
%264 = add nsw i32 %263, 1
store i32 %264, i32* %10
br label %212
265: ; preds = %212
%266 = call i32 @gettimeofday(%struct.timeval* %19, %struct.timezone* %20)
%267 = load i32, i32* %13
%268 = call i32 @omp_set_num_threads(i32 %267)
store i32 0, i32* %10
br label %269
269: ; preds = %328, %265
%270 = load i32, i32* %10
%271 = load i32, i32* %6
%272 = icmp slt i32 %270, %271
br i1 %272, label %273, label %331
273: ; preds = %269
store i32 0, i32* %11
br label %274
274: ; preds = %324, %273
%275 = load i32, i32* %11
%276 = load i32, i32* %9
%277 = icmp slt i32 %275, %276
br i1 %277, label %278, label %327
278: ; preds = %274
store i32 0, i32* %12
br label %279
279: ; preds = %320, %278
%280 = load i32, i32* %12
%281 = load i32, i32* %7
%282 = icmp slt i32 %280, %281
br i1 %282, label %283, label %323
283: ; preds = %279
%284 = load float**, float*** %16
%285 = load i32, i32* %10
%286 = sext i32 %285 to i64
%287 = getelementptr inbounds float*, float** %284, i64 %286
%288 = load float*, float** %287
%289 = load i32, i32* %11
%290 = sext i32 %289 to i64
%291 = getelementptr inbounds float, float* %288, i64 %290
%292 = load float, float* %291
%293 = load float**, float*** %14
%294 = load i32, i32* %10
%295 = sext i32 %294 to i64
%296 = getelementptr inbounds float*, float** %293, i64 %295
%297 = load float*, float** %296
%298 = load i32, i32* %12
%299 = sext i32 %298 to i64
%300 = getelementptr inbounds float, float* %297, i64 %299
%301 = load float, float* %300
%302 = load float**, float*** %15
%303 = load i32, i32* %12
%304 = sext i32 %303 to i64
%305 = getelementptr inbounds float*, float** %302, i64 %304
%306 = load float*, float** %305
%307 = load i32, i32* %11
%308 = sext i32 %307 to i64
%309 = getelementptr inbounds float, float* %306, i64 %308
%310 = load float, float* %309
%311 = call float @llvm.fmuladd.f32(float %301, float %310, float %292)
%312 = load float**, float*** %16
%313 = load i32, i32* %10
%314 = sext i32 %313 to i64
%315 = getelementptr inbounds float*, float** %312, i64 %314
%316 = load float*, float** %315
%317 = load i32, i32* %11
%318 = sext i32 %317 to i64
%319 = getelementptr inbounds float, float* %316, i64 %318
store float %311, float* %319
br label %320
320: ; preds = %283
%321 = load i32, i32* %12
%322 = add nsw i32 %321, 1
store i32 %322, i32* %12
br label %279
323: ; preds = %279
br label %324
324: ; preds = %323
%325 = load i32, i32* %11
%326 = add nsw i32 %325, 1
store i32 %326, i32* %11
br label %274
327: ; preds = %274
br label %328
328: ; preds = %327
%329 = load i32, i32* %10
%330 = add nsw i32 %329, 1
store i32 %330, i32* %10
br label %269
331: ; preds = %269
%332 = call i32 @gettimeofday(%struct.timeval* %21, %struct.timezone* %22)
%333 = getelementptr inbounds %struct.timeval, %struct.timeval* %19, i32 0, i32 0
%334 = load i32, i32* %333
%335 = mul nsw i32 %334, 1000000
%336 = getelementptr inbounds %struct.timeval, %struct.timeval* %19, i32 0, i32 1
%337 = load i32, i32* %336
%338 = add nsw i32 %335, %337
%339 = sext i32 %338 to i64
store i64 %339, i64* %23
%340 = getelementptr inbounds %struct.timeval, %struct.timeval* %21, i32 0, i32 0
%341 = load i32, i32* %340
%342 = mul nsw i32 %341, 1000000
%343 = getelementptr inbounds %struct.timeval, %struct.timeval* %21, i32 0, i32 1
%344 = load i32, i32* %343
%345 = add nsw i32 %342, %344
%346 = sext i32 %345 to i64
store i64 %346, i64* %24
%347 = load i64, i64* %24
%348 = load i64, i64* %23
%349 = sub nsw i64 %347, %348
%350 = sitofp i64 %349 to double
%351 = fdiv double %350, 1.000000e+06
store double %351, double* %25
store i32 0, i32* %10
br label %352
352: ; preds = %411, %331
%353 = load i32, i32* %10
%354 = load i32, i32* %6
%355 = icmp slt i32 %353, %354
br i1 %355, label %356, label %414
356: ; preds = %352
store i32 0, i32* %11
br label %357
357: ; preds = %407, %356
%358 = load i32, i32* %11
%359 = load i32, i32* %9
%360 = icmp slt i32 %358, %359
br i1 %360, label %361, label %410
361: ; preds = %357
store i32 0, i32* %12
br label %362
362: ; preds = %403, %361
%363 = load i32, i32* %12
%364 = load i32, i32* %7
%365 = icmp slt i32 %363, %364
br i1 %365, label %366, label %406
366: ; preds = %362
%367 = load float**, float*** %17
%368 = load i32, i32* %10
%369 = sext i32 %368 to i64
%370 = getelementptr inbounds float*, float** %367, i64 %369
%371 = load float*, float** %370
%372 = load i32, i32* %11
%373 = sext i32 %372 to i64
%374 = getelementptr inbounds float, float* %371, i64 %373
%375 = load float, float* %374
%376 = load float**, float*** %14
%377 = load i32, i32* %10
%378 = sext i32 %377 to i64
%379 = getelementptr inbounds float*, float** %376, i64 %378
%380 = load float*, float** %379
%381 = load i32, i32* %12
%382 = sext i32 %381 to i64
%383 = getelementptr inbounds float, float* %380, i64 %382
%384 = load float, float* %383
%385 = load float**, float*** %15
%386 = load i32, i32* %12
%387 = sext i32 %386 to i64
%388 = getelementptr inbounds float*, float** %385, i64 %387
%389 = load float*, float** %388
%390 = load i32, i32* %11
%391 = sext i32 %390 to i64
%392 = getelementptr inbounds float, float* %389, i64 %391
%393 = load float, float* %392
%394 = call float @llvm.fmuladd.f32(float %384, float %393, float %375)
%395 = load float**, float*** %17
%396 = load i32, i32* %10
%397 = sext i32 %396 to i64
%398 = getelementptr inbounds float*, float** %395, i64 %397
%399 = load float*, float** %398
%400 = load i32, i32* %11
%401 = sext i32 %400 to i64
%402 = getelementptr inbounds float, float* %399, i64 %401
store float %394, float* %402
br label %403
403: ; preds = %366
%404 = load i32, i32* %12
%405 = add nsw i32 %404, 1
store i32 %405, i32* %12
br label %362
406: ; preds = %362
br label %407
407: ; preds = %406
%408 = load i32, i32* %11
%409 = add nsw i32 %408, 1
store i32 %409, i32* %11
br label %357
410: ; preds = %357
br label %411
411: ; preds = %410
%412 = load i32, i32* %10
%413 = add nsw i32 %412, 1
store i32 %413, i32* %10
br label %352
414: ; preds = %352
store i32 0, i32* %10
br label %415
415: ; preds = %452, %414
%416 = load i32, i32* %10
%417 = load i32, i32* %6
%418 = icmp slt i32 %416, %417
br i1 %418, label %419, label %455
419: ; preds = %415
store i32 0, i32* %11
br label %420
420: ; preds = %448, %419
%421 = load i32, i32* %11
%422 = load i32, i32* %9
%423 = icmp slt i32 %421, %422
br i1 %423, label %424, label %451
424: ; preds = %420
%425 = load float**, float*** %17
%426 = load i32, i32* %10
%427 = sext i32 %426 to i64
%428 = getelementptr inbounds float*, float** %425, i64 %427
%429 = load float*, float** %428
%430 = load i32, i32* %11
%431 = sext i32 %430 to i64
%432 = getelementptr inbounds float, float* %429, i64 %431
%433 = load float, float* %432
%434 = load float**, float*** %16
%435 = load i32, i32* %10
%436 = sext i32 %435 to i64
%437 = getelementptr inbounds float*, float** %434, i64 %436
%438 = load float*, float** %437
%439 = load i32, i32* %11
%440 = sext i32 %439 to i64
%441 = getelementptr inbounds float, float* %438, i64 %440
%442 = load float, float* %441
%443 = fcmp oeq float %433, %442
br i1 %443, label %444, label %445
444: ; preds = %424
br label %448
445: ; preds = %424
%446 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.14, i64 0, i64 0))
%447 = call i32 @exit(i32 1)
unreachable
448: ; preds = %444
%449 = load i32, i32* %11
%450 = add nsw i32 %449, 1
store i32 %450, i32* %11
br label %420
451: ; preds = %420
br label %452
452: ; preds = %451
%453 = load i32, i32* %10
%454 = add nsw i32 %453, 1
store i32 %454, i32* %10
br label %415
455: ; preds = %415
%456 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([80 x i8], [80 x i8]* @.str.15, i64 0, i64 0))
%457 = load double, double* %25
%458 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.16, i64 0, i64 0), double %457)
%459 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([54 x i8], [54 x i8]* @.str.17, i64 0, i64 0))
%460 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([79 x i8], [79 x i8]* @.str.5, i64 0, i64 0))
%461 = load float**, float*** %14
%462 = call i32 @free(float** %461)
%463 = load float**, float*** %15
%464 = call i32 @free(float** %463)
%465 = load float**, float*** %16
%466 = call i32 @free(float** %465)
%467 = load float**, float*** %17
%468 = call i32 @free(float** %467)
%469 = load i32, i32* %3
ret i32 %469
}

LLVM IR (-O2):
%struct.timeval = type { i32, i32 }
%struct.timezone = type { i32 }
@.str = [79 x i8] c"\0A\09\09---------------------------------------------------------------------------\00"
@.str.1 = [19 x i8] c"\0A\09\09 Email : RarchK\00"
@.str.2 = [72 x i8] c"\0A\09\09 Objective : Dense Matrix Computations (Floating Point Operations)\0A \00"
@.str.3 = [45 x i8] c"\0A\09\09 Matrix into Matrix Multiplication using \00"
@.str.4 = [58 x i8] c"\0A\09\09 OpenMP one PARALLEL for directive and Private Clause;\00"
@.str.6 = [24 x i8] c"\09\09 Very Few Arguments\0A \00"
@.str.9 = [25 x i8] c"\0A\09\09 Threads : %d \00"
@.str.10 = [30 x i8] c"\0A\09\09 Matrix A Size : %d X %d \00"
@.str.11 = [30 x i8] c"\0A\09\09 Matrix B Size : %d X %d \00"
@.str.16 = [47 x i8] c"\0A\09\09 Time in Seconds (T) : %lf Seconds \0A\00"
@.str.17 = [54 x i8] c"\0A\09\09 ( T represents the Time taken for computation )\00"
@str.18 = [79 x i8] c"\0A\0A\09\09 Matrix into Matrix Multiplication using Parallel for directive......Done \00"
@str.19 = [78 x i8] c"\0A\09\09..........................................................................\00"
@str.20 = [51 x i8] c"\0A\09\09 There Is A Difference In Parallel Calculation \00"
@str.21 = [47 x i8] c"\0A\09\09 Matrix Matrix Computation Is Not Possible \00"
@str.22 = [57 x i8] c"\0A\09\09 The NoofRows And NoofCols Should Be Of Positive Sign\00"
@str.23 = [76 x i8] c"\0A Number of threads should be 1,2,4,8 or 16 for the execution of program. \0A\00"
@str.24 = [80 x i8] c"\09\09 Syntax : exec <Threads> <NoOfRows A> <NoOfCols A> <NoOfRows B> <NoOfCols B>\00"
define i32 @main(i32 %0, i8** nocapture %1) {
%3 = alloca %struct.timeval
%4 = alloca %struct.timezone
%5 = alloca %struct.timeval
%6 = alloca %struct.timezone
%7 = bitcast %struct.timeval* %3 to i8*
%8 = bitcast %struct.timezone* %4 to i8*
%9 = bitcast %struct.timeval* %5 to i8*
%10 = bitcast %struct.timezone* %6 to i8*
%11 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([79 x i8], [79 x i8]* @.str, i64 0, i64 0))
%12 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @.str.1, i64 0, i64 0))
%13 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([79 x i8], [79 x i8]* @.str, i64 0, i64 0))
%14 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([72 x i8], [72 x i8]* @.str.2, i64 0, i64 0))
%15 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([45 x i8], [45 x i8]* @.str.3, i64 0, i64 0))
%16 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([58 x i8], [58 x i8]* @.str.4, i64 0, i64 0))
%17 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([78 x i8], [78 x i8]* @str.19, i64 0, i64 0))
%18 = icmp eq i32 %0, 6
br i1 %18, label %23, label %19
19: ; preds = %2
%20 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([24 x i8], [24 x i8]* @.str.6, i64 0, i64 0))
%21 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([80 x i8], [80 x i8]* @str.24, i64 0, i64 0))
%22 = tail call i32 @exit(i32 -1)
unreachable
23: ; preds = %2
%24 = getelementptr inbounds i8*, i8** %1, i64 1
%25 = load i8*, i8** %24
%26 = tail call i32 @atoi(i8* %25)
switch i32 %26, label %27 [
i32 16, label %30
i32 8, label %30
i32 4, label %30
i32 2, label %30
i32 1, label %30
]
27: ; preds = %23
%28 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([76 x i8], [76 x i8]* @str.23, i64 0, i64 0))
%29 = tail call i32 @exit(i32 -1)
unreachable
30: ; preds = %23, %23, %23, %23, %23
%31 = getelementptr inbounds i8*, i8** %1, i64 2
%32 = load i8*, i8** %31
%33 = tail call i32 @atoi(i8* %32)
%34 = getelementptr inbounds i8*, i8** %1, i64 3
%35 = load i8*, i8** %34
%36 = tail call i32 @atoi(i8* %35)
%37 = getelementptr inbounds i8*, i8** %1, i64 4
%38 = load i8*, i8** %37
%39 = tail call i32 @atoi(i8* %38)
%40 = getelementptr inbounds i8*, i8** %1, i64 5
%41 = load i8*, i8** %40
%42 = tail call i32 @atoi(i8* %41)
%43 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([25 x i8], [25 x i8]* @.str.9, i64 0, i64 0), i32 %26)
%44 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([30 x i8], [30 x i8]* @.str.10, i64 0, i64 0), i32 %33, i32 %36)
%45 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([30 x i8], [30 x i8]* @.str.11, i64 0, i64 0), i32 %39, i32 %42)
%46 = icmp slt i32 %33, 1
%47 = icmp slt i32 %36, 1
%48 = select i1 %46, i1 true, i1 %47
%49 = icmp slt i32 %39, 1
%50 = select i1 %48, i1 true, i1 %49
%51 = icmp slt i32 %42, 1
%52 = select i1 %50, i1 true, i1 %51
br i1 %52, label %53, label %56
53: ; preds = %30
%54 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([57 x i8], [57 x i8]* @str.22, i64 0, i64 0))
%55 = tail call i32 @exit(i32 1)
unreachable
56: ; preds = %30
%57 = icmp eq i32 %36, %39
br i1 %57, label %61, label %58
58: ; preds = %56
%59 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @str.21, i64 0, i64 0))
%60 = tail call i32 @exit(i32 1)
unreachable
61: ; preds = %56
%62 = shl i32 %33, 3
%63 = tail call i64 @malloc(i32 %62)
%64 = inttoptr i64 %63 to float**
%65 = shl i32 %36, 2
%66 = zext i32 %33 to i64
%67 = zext i32 %36 to i64
%68 = icmp ult i32 %36, 8
%69 = and i64 %67, 4294967288
%70 = icmp eq i64 %69, %67
br label %71
71: ; preds = %61, %109
%72 = phi i64 [ 0, %61 ], [ %110, %109 ]
%73 = tail call i64 @malloc(i32 %65)
%74 = inttoptr i64 %73 to float*
%75 = getelementptr inbounds float*, float** %64, i64 %72
store float* %74, float** %75
br i1 %68, label %99, label %76
76: ; preds = %71
%77 = insertelement <4 x i64> poison, i64 %72, i64 0
%78 = shufflevector <4 x i64> %77, <4 x i64> poison, <4 x i32> zeroinitializer
%79 = add nuw i64 %72, 4
%80 = insertelement <4 x i64> poison, i64 %79, i64 0
%81 = shufflevector <4 x i64> %80, <4 x i64> poison, <4 x i32> zeroinitializer
br label %82
82: ; preds = %82, %76
%83 = phi i64 [ 0, %76 ], [ %95, %82 ]
%84 = phi <4 x i64> [ <i64 0, i64 1, i64 2, i64 3>, %76 ], [ %96, %82 ]
%85 = add nuw nsw <4 x i64> %84, %78
%86 = add <4 x i64> %81, %84
%87 = trunc <4 x i64> %85 to <4 x i32>
%88 = trunc <4 x i64> %86 to <4 x i32>
%89 = sitofp <4 x i32> %87 to <4 x float>
%90 = sitofp <4 x i32> %88 to <4 x float>
%91 = getelementptr inbounds float, float* %74, i64 %83
%92 = bitcast float* %91 to <4 x float>*
store <4 x float> %89, <4 x float>* %92
%93 = getelementptr inbounds float, float* %91, i64 4
%94 = bitcast float* %93 to <4 x float>*
store <4 x float> %90, <4 x float>* %94
%95 = add nuw i64 %83, 8
%96 = add <4 x i64> %84, <i64 8, i64 8, i64 8, i64 8>
%97 = icmp eq i64 %95, %69
br i1 %97, label %98, label %82
98: ; preds = %82
br i1 %70, label %109, label %99
99: ; preds = %71, %98
%100 = phi i64 [ 0, %71 ], [ %69, %98 ]
br label %101
101: ; preds = %99, %101
%102 = phi i64 [ %107, %101 ], [ %100, %99 ]
%103 = add nuw nsw i64 %102, %72
%104 = trunc i64 %103 to i32
%105 = sitofp i32 %104 to float
%106 = getelementptr inbounds float, float* %74, i64 %102
store float %105, float* %106
%107 = add nuw nsw i64 %102, 1
%108 = icmp eq i64 %107, %67
br i1 %108, label %109, label %101
109: ; preds = %101, %98
%110 = add nuw nsw i64 %72, 1
%111 = icmp eq i64 %110, %66
br i1 %111, label %112, label %71
112: ; preds = %109
%113 = shl i32 %36, 3
%114 = tail call i64 @malloc(i32 %113)
%115 = inttoptr i64 %114 to float**
%116 = icmp sgt i32 %36, 0
br i1 %116, label %117, label %167
117: ; preds = %112
%118 = shl i32 %42, 2
%119 = icmp sgt i32 %42, 0
%120 = zext i32 %36 to i64
%121 = zext i32 %42 to i64
%122 = icmp ult i32 %42, 8
%123 = and i64 %121, 4294967288
%124 = icmp eq i64 %123, %121
br label %125
125: ; preds = %117, %164
%126 = phi i64 [ 0, %117 ], [ %165, %164 ]
%127 = tail call i64 @malloc(i32 %118)
%128 = inttoptr i64 %127 to float*
%129 = getelementptr inbounds float*, float** %115, i64 %126
store float* %128, float** %129
br i1 %119, label %130, label %164
130: ; preds = %125
br i1 %122, label %154, label %131
131: ; preds = %130
%132 = insertelement <4 x i64> poison, i64 %126, i64 0
%133 = shufflevector <4 x i64> %132, <4 x i64> poison, <4 x i32> zeroinitializer
%134 = add nuw i64 %126, 4
%135 = insertelement <4 x i64> poison, i64 %134, i64 0
%136 = shufflevector <4 x i64> %135, <4 x i64> poison, <4 x i32> zeroinitializer
br label %137
137: ; preds = %137, %131
%138 = phi i64 [ 0, %131 ], [ %150, %137 ]
%139 = phi <4 x i64> [ <i64 0, i64 1, i64 2, i64 3>, %131 ], [ %151, %137 ]
%140 = add nuw nsw <4 x i64> %139, %133
%141 = add <4 x i64> %136, %139
%142 = trunc <4 x i64> %140 to <4 x i32>
%143 = trunc <4 x i64> %141 to <4 x i32>
%144 = sitofp <4 x i32> %142 to <4 x float>
%145 = sitofp <4 x i32> %143 to <4 x float>
%146 = getelementptr inbounds float, float* %128, i64 %138
%147 = bitcast float* %146 to <4 x float>*
store <4 x float> %144, <4 x float>* %147
%148 = getelementptr inbounds float, float* %146, i64 4
%149 = bitcast float* %148 to <4 x float>*
store <4 x float> %145, <4 x float>* %149
%150 = add nuw i64 %138, 8
%151 = add <4 x i64> %139, <i64 8, i64 8, i64 8, i64 8>
%152 = icmp eq i64 %150, %123
br i1 %152, label %153, label %137
153: ; preds = %137
br i1 %124, label %164, label %154
154: ; preds = %130, %153
%155 = phi i64 [ 0, %130 ], [ %123, %153 ]
br label %156
156: ; preds = %154, %156
%157 = phi i64 [ %162, %156 ], [ %155, %154 ]
%158 = add nuw nsw i64 %157, %126
%159 = trunc i64 %158 to i32
%160 = sitofp i32 %159 to float
%161 = getelementptr inbounds float, float* %128, i64 %157
store float %160, float* %161
%162 = add nuw nsw i64 %157, 1
%163 = icmp eq i64 %162, %121
br i1 %163, label %164, label %156
164: ; preds = %156, %153, %125
%165 = add nuw nsw i64 %126, 1
%166 = icmp eq i64 %165, %120
br i1 %166, label %167, label %125
167: ; preds = %164, %112
%168 = tail call i64 @malloc(i32 %62)
%169 = inttoptr i64 %168 to float**
%170 = tail call i64 @malloc(i32 %62)
%171 = inttoptr i64 %170 to float**
%172 = shl i32 %42, 2
%173 = icmp sgt i32 %42, 0
%174 = zext i32 %33 to i64
%175 = zext i32 %42 to i64
%176 = and i64 %175, 4294967288
%177 = add nsw i64 %176, -8
%178 = lshr exact i64 %177, 3
%179 = add nuw nsw i64 %178, 1
%180 = icmp ult i32 %42, 8
%181 = and i64 %175, 4294967288
%182 = and i64 %179, 3
%183 = icmp ult i64 %177, 24
%184 = and i64 %179, 4611686018427387900
%185 = icmp eq i64 %182, 0
%186 = icmp eq i64 %181, %175
%187 = and i64 %175, 3
%188 = icmp eq i64 %187, 0
br label %189
189: ; preds = %167, %296
%190 = phi i64 [ 0, %167 ], [ %297, %296 ]
%191 = tail call i64 @malloc(i32 %172)
%192 = inttoptr i64 %191 to float*
%193 = getelementptr inbounds float*, float** %169, i64 %190
store float* %192, float** %193
%194 = tail call i64 @malloc(i32 %172)
%195 = inttoptr i64 %194 to float*
%196 = inttoptr i64 %194 to i8*
%197 = getelementptr inbounds float*, float** %171, i64 %190
store float* %195, float** %197
br i1 %173, label %198, label %296
198: ; preds = %189
%199 = load float*, float** %193
br i1 %180, label %266, label %200
200: ; preds = %198
%201 = getelementptr float, float* %199, i64 %175
%202 = bitcast float* %201 to i8*
%203 = getelementptr float, float* %195, i64 %175
%204 = icmp ult float* %199, %203
%205 = icmp ult i8* %196, %202
%206 = and i1 %204, %205
br i1 %206, label %266, label %207
207: ; preds = %200
br i1 %183, label %249, label %208
208: ; preds = %207, %208
%209 = phi i64 [ %246, %208 ], [ 0, %207 ]
%210 = phi i64 [ %247, %208 ], [ 0, %207 ]
%211 = getelementptr inbounds float, float* %199, i64 %209
%212 = bitcast float* %211 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %212
%213 = getelementptr inbounds float, float* %211, i64 4
%214 = bitcast float* %213 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %214
%215 = getelementptr inbounds float, float* %195, i64 %209
%216 = bitcast float* %215 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %216
%217 = getelementptr inbounds float, float* %215, i64 4
%218 = bitcast float* %217 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %218
%219 = or i64 %209, 8
%220 = getelementptr inbounds float, float* %199, i64 %219
%221 = bitcast float* %220 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %221
%222 = getelementptr inbounds float, float* %220, i64 4
%223 = bitcast float* %222 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %223
%224 = getelementptr inbounds float, float* %195, i64 %219
%225 = bitcast float* %224 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %225
%226 = getelementptr inbounds float, float* %224, i64 4
%227 = bitcast float* %226 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %227
%228 = or i64 %209, 16
%229 = getelementptr inbounds float, float* %199, i64 %228
%230 = bitcast float* %229 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %230
%231 = getelementptr inbounds float, float* %229, i64 4
%232 = bitcast float* %231 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %232
%233 = getelementptr inbounds float, float* %195, i64 %228
%234 = bitcast float* %233 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %234
%235 = getelementptr inbounds float, float* %233, i64 4
%236 = bitcast float* %235 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %236
%237 = or i64 %209, 24
%238 = getelementptr inbounds float, float* %199, i64 %237
%239 = bitcast float* %238 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %239
%240 = getelementptr inbounds float, float* %238, i64 4
%241 = bitcast float* %240 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %241
%242 = getelementptr inbounds float, float* %195, i64 %237
%243 = bitcast float* %242 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %243
%244 = getelementptr inbounds float, float* %242, i64 4
%245 = bitcast float* %244 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %245
%246 = add nuw i64 %209, 32
%247 = add i64 %210, 4
%248 = icmp eq i64 %247, %184
br i1 %248, label %249, label %208
249: ; preds = %208, %207
%250 = phi i64 [ 0, %207 ], [ %246, %208 ]
br i1 %185, label %265, label %251
251: ; preds = %249, %251
%252 = phi i64 [ %262, %251 ], [ %250, %249 ]
%253 = phi i64 [ %263, %251 ], [ 0, %249 ]
%254 = getelementptr inbounds float, float* %199, i64 %252
%255 = bitcast float* %254 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %255
%256 = getelementptr inbounds float, float* %254, i64 4
%257 = bitcast float* %256 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %257
%258 = getelementptr inbounds float, float* %195, i64 %252
%259 = bitcast float* %258 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %259
%260 = getelementptr inbounds float, float* %258, i64 4
%261 = bitcast float* %260 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %261
%262 = add nuw i64 %252, 8
%263 = add i64 %253, 1
%264 = icmp eq i64 %263, %182
br i1 %264, label %265, label %251
265: ; preds = %251, %249
br i1 %186, label %296, label %266
266: ; preds = %200, %198, %265
%267 = phi i64 [ 0, %200 ], [ 0, %198 ], [ %181, %265 ]
%268 = xor i64 %267, -1
%269 = add nsw i64 %268, %175
br i1 %188, label %278, label %270
270: ; preds = %266, %270
%271 = phi i64 [ %275, %270 ], [ %267, %266 ]
%272 = phi i64 [ %276, %270 ], [ 0, %266 ]
%273 = getelementptr inbounds float, float* %199, i64 %271
store float 0.000000e+00, float* %273
%274 = getelementptr inbounds float, float* %195, i64 %271
store float 0.000000e+00, float* %274
%275 = add nuw nsw i64 %271, 1
%276 = add i64 %272, 1
%277 = icmp eq i64 %276, %187
br i1 %277, label %278, label %270
278: ; preds = %270, %266
%279 = phi i64 [ %267, %266 ], [ %275, %270 ]
%280 = icmp ult i64 %269, 3
br i1 %280, label %296, label %281
281: ; preds = %278, %281
%282 = phi i64 [ %294, %281 ], [ %279, %278 ]
%283 = getelementptr inbounds float, float* %199, i64 %282
store float 0.000000e+00, float* %283
%284 = getelementptr inbounds float, float* %195, i64 %282
store float 0.000000e+00, float* %284
%285 = add nuw nsw i64 %282, 1
%286 = getelementptr inbounds float, float* %199, i64 %285
store float 0.000000e+00, float* %286
%287 = getelementptr inbounds float, float* %195, i64 %285
store float 0.000000e+00, float* %287
%288 = add nuw nsw i64 %282, 2
%289 = getelementptr inbounds float, float* %199, i64 %288
store float 0.000000e+00, float* %289
%290 = getelementptr inbounds float, float* %195, i64 %288
store float 0.000000e+00, float* %290
%291 = add nuw nsw i64 %282, 3
%292 = getelementptr inbounds float, float* %199, i64 %291
store float 0.000000e+00, float* %292
%293 = getelementptr inbounds float, float* %195, i64 %291
store float 0.000000e+00, float* %293
%294 = add nuw nsw i64 %282, 4
%295 = icmp eq i64 %294, %175
br i1 %295, label %296, label %281
296: ; preds = %278, %281, %265, %189
%297 = add nuw nsw i64 %190, 1
%298 = icmp eq i64 %297, %174
br i1 %298, label %299, label %189
299: ; preds = %296
%300 = call i32 @gettimeofday(%struct.timeval* %3, %struct.timezone* %4)
%301 = tail call i32 @omp_set_num_threads(i32 %26)
%302 = icmp sgt i32 %42, 0
%303 = zext i32 %33 to i64
%304 = zext i32 %42 to i64
%305 = add nsw i64 %67, -1
%306 = and i64 %67, 1
%307 = icmp eq i64 %305, 0
%308 = and i64 %67, 4294967294
%309 = icmp eq i64 %306, 0
br label %310
310: ; preds = %299, %358
%311 = phi i64 [ 0, %299 ], [ %359, %358 ]
br i1 %302, label %312, label %358
312: ; preds = %310
%313 = getelementptr inbounds float*, float** %169, i64 %311
%314 = getelementptr inbounds float*, float** %64, i64 %311
br label %315
315: ; preds = %312, %355
%316 = phi i64 [ 0, %312 ], [ %356, %355 ]
br i1 %116, label %317, label %355
317: ; preds = %315
%318 = load float*, float** %313
%319 = getelementptr inbounds float, float* %318, i64 %316
%320 = load float*, float** %314
%321 = load float, float* %319
br i1 %307, label %344, label %322
322: ; preds = %317, %322
%323 = phi float [ %340, %322 ], [ %321, %317 ]
%324 = phi i64 [ %341, %322 ], [ 0, %317 ]
%325 = phi i64 [ %342, %322 ], [ 0, %317 ]
%326 = getelementptr inbounds float, float* %320, i64 %324
%327 = load float, float* %326
%328 = getelementptr inbounds float*, float** %115, i64 %324
%329 = load float*, float** %328
%330 = getelementptr inbounds float, float* %329, i64 %316
%331 = load float, float* %330
%332 = tail call float @llvm.fmuladd.f32(float %327, float %331, float %323)
store float %332, float* %319
%333 = or i64 %324, 1
%334 = getelementptr inbounds float, float* %320, i64 %333
%335 = load float, float* %334
%336 = getelementptr inbounds float*, float** %115, i64 %333
%337 = load float*, float** %336
%338 = getelementptr inbounds float, float* %337, i64 %316
%339 = load float, float* %338
%340 = tail call float @llvm.fmuladd.f32(float %335, float %339, float %332)
store float %340, float* %319
%341 = add nuw nsw i64 %324, 2
%342 = add i64 %325, 2
%343 = icmp eq i64 %342, %308
br i1 %343, label %344, label %322
344: ; preds = %322, %317
%345 = phi float [ %321, %317 ], [ %340, %322 ]
%346 = phi i64 [ 0, %317 ], [ %341, %322 ]
br i1 %309, label %355, label %347
347: ; preds = %344
%348 = getelementptr inbounds float, float* %320, i64 %346
%349 = load float, float* %348
%350 = getelementptr inbounds float*, float** %115, i64 %346
%351 = load float*, float** %350
%352 = getelementptr inbounds float, float* %351, i64 %316
%353 = load float, float* %352
%354 = tail call float @llvm.fmuladd.f32(float %349, float %353, float %345)
store float %354, float* %319
br label %355
355: ; preds = %347, %344, %315
%356 = add nuw nsw i64 %316, 1
%357 = icmp eq i64 %356, %304
br i1 %357, label %358, label %315
358: ; preds = %355, %310
%359 = add nuw nsw i64 %311, 1
%360 = icmp eq i64 %359, %303
br i1 %360, label %361, label %310
361: ; preds = %358
%362 = call i32 @gettimeofday(%struct.timeval* %5, %struct.timezone* %6)
%363 = getelementptr inbounds %struct.timeval, %struct.timeval* %3, i64 0, i32 0
%364 = load i32, i32* %363
%365 = getelementptr inbounds %struct.timeval, %struct.timeval* %3, i64 0, i32 1
%366 = load i32, i32* %365
%367 = getelementptr inbounds %struct.timeval, %struct.timeval* %5, i64 0, i32 0
%368 = load i32, i32* %367
%369 = getelementptr inbounds %struct.timeval, %struct.timeval* %5, i64 0, i32 1
%370 = load i32, i32* %369
%371 = icmp sgt i32 %42, 0
%372 = zext i32 %33 to i64
%373 = zext i32 %42 to i64
%374 = and i64 %67, 1
%375 = icmp eq i64 %305, 0
%376 = and i64 %67, 4294967294
%377 = icmp eq i64 %374, 0
br label %378
378: ; preds = %361, %430
%379 = phi i64 [ 0, %361 ], [ %431, %430 ]
br i1 %371, label %380, label %430
380: ; preds = %378
%381 = getelementptr inbounds float*, float** %171, i64 %379
%382 = getelementptr inbounds float*, float** %64, i64 %379
br label %387
383: ; preds = %430
%384 = icmp sgt i32 %42, 0
%385 = zext i32 %33 to i64
%386 = zext i32 %42 to i64
br label %433
387: ; preds = %380, %427
%388 = phi i64 [ 0, %380 ], [ %428, %427 ]
br i1 %116, label %389, label %427
389: ; preds = %387
%390 = load float*, float** %381
%391 = getelementptr inbounds float, float* %390, i64 %388
%392 = load float*, float** %382
%393 = load float, float* %391
br i1 %375, label %416, label %394
394: ; preds = %389, %394
%395 = phi float [ %412, %394 ], [ %393, %389 ]
%396 = phi i64 [ %413, %394 ], [ 0, %389 ]
%397 = phi i64 [ %414, %394 ], [ 0, %389 ]
%398 = getelementptr inbounds float, float* %392, i64 %396
%399 = load float, float* %398
%400 = getelementptr inbounds float*, float** %115, i64 %396
%401 = load float*, float** %400
%402 = getelementptr inbounds float, float* %401, i64 %388
%403 = load float, float* %402
%404 = tail call float @llvm.fmuladd.f32(float %399, float %403, float %395)
store float %404, float* %391
%405 = or i64 %396, 1
%406 = getelementptr inbounds float, float* %392, i64 %405
%407 = load float, float* %406
%408 = getelementptr inbounds float*, float** %115, i64 %405
%409 = load float*, float** %408
%410 = getelementptr inbounds float, float* %409, i64 %388
%411 = load float, float* %410
%412 = tail call float @llvm.fmuladd.f32(float %407, float %411, float %404)
store float %412, float* %391
%413 = add nuw nsw i64 %396, 2
%414 = add i64 %397, 2
%415 = icmp eq i64 %414, %376
br i1 %415, label %416, label %394
416: ; preds = %394, %389
%417 = phi float [ %393, %389 ], [ %412, %394 ]
%418 = phi i64 [ 0, %389 ], [ %413, %394 ]
br i1 %377, label %427, label %419
419: ; preds = %416
%420 = getelementptr inbounds float, float* %392, i64 %418
%421 = load float, float* %420
%422 = getelementptr inbounds float*, float** %115, i64 %418
%423 = load float*, float** %422
%424 = getelementptr inbounds float, float* %423, i64 %388
%425 = load float, float* %424
%426 = tail call float @llvm.fmuladd.f32(float %421, float %425, float %417)
store float %426, float* %391
br label %427
427: ; preds = %419, %416, %387
%428 = add nuw nsw i64 %388, 1
%429 = icmp eq i64 %428, %373
br i1 %429, label %430, label %387
430: ; preds = %427, %378
%431 = add nuw nsw i64 %379, 1
%432 = icmp eq i64 %431, %372
br i1 %432, label %383, label %378
433: ; preds = %383, %453
%434 = phi i64 [ 0, %383 ], [ %454, %453 ]
br i1 %384, label %435, label %453
435: ; preds = %433
%436 = getelementptr inbounds float*, float** %171, i64 %434
%437 = load float*, float** %436
%438 = getelementptr inbounds float*, float** %169, i64 %434
%439 = load float*, float** %438
br label %442
440: ; preds = %442
%441 = icmp eq i64 %449, %386
br i1 %441, label %453, label %442
442: ; preds = %435, %440
%443 = phi i64 [ 0, %435 ], [ %449, %440 ]
%444 = getelementptr inbounds float, float* %437, i64 %443
%445 = load float, float* %444
%446 = getelementptr inbounds float, float* %439, i64 %443
%447 = load float, float* %446
%448 = fcmp oeq float %445, %447
%449 = add nuw nsw i64 %443, 1
br i1 %448, label %440, label %450
450: ; preds = %442
%451 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([51 x i8], [51 x i8]* @str.20, i64 0, i64 0))
%452 = tail call i32 @exit(i32 1)
unreachable
453: ; preds = %440, %433
%454 = add nuw nsw i64 %434, 1
%455 = icmp eq i64 %454, %385
br i1 %455, label %456, label %433
456: ; preds = %453
%457 = mul nsw i32 %368, 1000000
%458 = add nsw i32 %457, %370
%459 = sext i32 %458 to i64
%460 = mul nsw i32 %364, 1000000
%461 = add nsw i32 %460, %366
%462 = sext i32 %461 to i64
%463 = sub nsw i64 %459, %462
%464 = sitofp i64 %463 to double
%465 = fdiv double %464, 1.000000e+06
%466 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([79 x i8], [79 x i8]* @str.18, i64 0, i64 0))
%467 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @.str.16, i64 0, i64 0), double %465)
%468 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([54 x i8], [54 x i8]* @.str.17, i64 0, i64 0))
%469 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([78 x i8], [78 x i8]* @str.19, i64 0, i64 0))
%470 = tail call i32 @free(float** %64)
%471 = tail call i32 @free(float** %115)
%472 = tail call i32 @free(float** %169)
%473 = tail call i32 @free(float** %171)
ret i32 0
}