#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*/ free(float **);
double get_cur_time();
scalar_t__ malloc(int);
int /*<<< orphan*/ matmatijk(int, float **, float **, float **, int);
int /*<<< orphan*/ matmatikj(int, float **, float **, float **, int);
int /*<<< orphan*/ matmatjik(int, float **, float **, float **, int);
int /*<<< orphan*/ matmatjki(int, float **, float **, float **, int);
int /*<<< orphan*/ matmatkij(int, float **, float **, float **, int);
int /*<<< orphan*/ matmatkji(int, float **, float **, float **, int);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ randomMatrix(int, float **, float **, float **, int);
int /*<<< orphan*/ srand(unsigned int);
scalar_t__ time(int /*<<< orphan*/ *);
int main(int argc, const char *argv[]) {
  srand((unsigned int)time(NULL));
  int LD = 500, N = 100;
  float **A = NULL, **B = NULL, **C = NULL;
  double inizio, fine;
  A = (float **)malloc(LD * LD * sizeof(float));
  B = (float **)malloc(LD * LD * sizeof(float));
  C = (float **)malloc(LD * LD * sizeof(float));
  printf("\n");
  randomMatrix(LD, (float(*)[LD])A, (float(*)[LD])B, (float(*)[LD])C, N);
  inizio = get_cur_time();
  matmatijk(LD, (float(*)[LD])A, (float(*)[LD])B, (float(*)[LD])C, N);
  fine = get_cur_time();
  printf("IJK - Elapsed time: %lfs\n", fine - inizio);
  inizio = get_cur_time();
  matmatjik(LD, (float(*)[LD])A, (float(*)[LD])B, (float(*)[LD])C, N);
  fine = get_cur_time();
  printf("JIK - Elapsed time: %lfs\n", fine - inizio);
  inizio = get_cur_time();
  matmatikj(LD, (float(*)[LD])A, (float(*)[LD])B, (float(*)[LD])C, N);
  fine = get_cur_time();
  printf("IKJ - Elapsed time: %lfs\n", fine - inizio);
  inizio = get_cur_time();
  matmatjki(LD, (float(*)[LD])A, (float(*)[LD])B, (float(*)[LD])C, N);
  fine = get_cur_time();
  printf("JKI - Elapsed time: %lfs\n", fine - inizio);
  inizio = get_cur_time();
  matmatkij(LD, (float(*)[LD])A, (float(*)[LD])B, (float(*)[LD])C, N);
  fine = get_cur_time();
  printf("KIJ - Elapsed time: %lfs\n", fine - inizio);
  inizio = get_cur_time();
  matmatkji(LD, (float(*)[LD])A, (float(*)[LD])B, (float(*)[LD])C, N);
  fine = get_cur_time();
  printf("KJI - Elapsed time: %lfs\n", fine - inizio);
  free(A);
  free(B);
  free(C);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
xor    %eax,%eax
mov    %eax,%edi
call   10b0 <time@plt>
mov    %eax,%edi
call   1090 <srand@plt>
movl   $0x1f4,-0x14(%rbp)
movl   $0x64,-0x18(%rbp)
movq   $0x0,-0x20(%rbp)
movq   $0x0,-0x28(%rbp)
movq   $0x0,-0x30(%rbp)
mov    -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   10c0 <malloc@plt>
mov    %rax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   10c0 <malloc@plt>
mov    %rax,-0x28(%rbp)
mov    -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   10c0 <malloc@plt>
mov    %rax,-0x30(%rbp)
lea    0xe2f(%rip),%rdi
mov    $0x0,%al
call   1070 <printf@plt>
mov    -0x14(%rbp),%edi
mov    -0x20(%rbp),%rsi
mov    -0x28(%rbp),%rdx
mov    -0x30(%rbp),%rcx
mov    -0x18(%rbp),%r8d
call   1060 <randomMatrix@plt>
mov    $0x0,%al
call   10a0 <get_cur_time@plt>
movsd  %xmm0,-0x38(%rbp)
mov    -0x14(%rbp),%edi
mov    -0x20(%rbp),%rsi
mov    -0x28(%rbp),%rdx
mov    -0x30(%rbp),%rcx
mov    -0x18(%rbp),%r8d
call   1050 <matmatijk@plt>
mov    $0x0,%al
call   10a0 <get_cur_time@plt>
movsd  %xmm0,-0x40(%rbp)
movsd  -0x40(%rbp),%xmm0
subsd  -0x38(%rbp),%xmm0
lea    0xd35(%rip),%rdi
mov    $0x1,%al
call   1070 <printf@plt>
mov    $0x0,%al
call   10a0 <get_cur_time@plt>
movsd  %xmm0,-0x38(%rbp)
mov    -0x14(%rbp),%edi
mov    -0x20(%rbp),%rsi
mov    -0x28(%rbp),%rdx
mov    -0x30(%rbp),%rcx
mov    -0x18(%rbp),%r8d
call   10d0 <matmatjik@plt>
mov    $0x0,%al
call   10a0 <get_cur_time@plt>
movsd  %xmm0,-0x40(%rbp)
movsd  -0x40(%rbp),%xmm0
subsd  -0x38(%rbp),%xmm0
lea    0xd07(%rip),%rdi
mov    $0x1,%al
call   1070 <printf@plt>
mov    $0x0,%al
call   10a0 <get_cur_time@plt>
movsd  %xmm0,-0x38(%rbp)
mov    -0x14(%rbp),%edi
mov    -0x20(%rbp),%rsi
mov    -0x28(%rbp),%rdx
mov    -0x30(%rbp),%rcx
mov    -0x18(%rbp),%r8d
call   10f0 <matmatikj@plt>
mov    $0x0,%al
call   10a0 <get_cur_time@plt>
movsd  %xmm0,-0x40(%rbp)
movsd  -0x40(%rbp),%xmm0
subsd  -0x38(%rbp),%xmm0
lea    0xcd9(%rip),%rdi
mov    $0x1,%al
call   1070 <printf@plt>
mov    $0x0,%al
call   10a0 <get_cur_time@plt>
movsd  %xmm0,-0x38(%rbp)
mov    -0x14(%rbp),%edi
mov    -0x20(%rbp),%rsi
mov    -0x28(%rbp),%rdx
mov    -0x30(%rbp),%rcx
mov    -0x18(%rbp),%r8d
call   1030 <matmatjki@plt>
mov    $0x0,%al
call   10a0 <get_cur_time@plt>
movsd  %xmm0,-0x40(%rbp)
movsd  -0x40(%rbp),%xmm0
subsd  -0x38(%rbp),%xmm0
lea    0xcab(%rip),%rdi
mov    $0x1,%al
call   1070 <printf@plt>
mov    $0x0,%al
call   10a0 <get_cur_time@plt>
movsd  %xmm0,-0x38(%rbp)
mov    -0x14(%rbp),%edi
mov    -0x20(%rbp),%rsi
mov    -0x28(%rbp),%rdx
mov    -0x30(%rbp),%rcx
mov    -0x18(%rbp),%r8d
call   10e0 <matmatkij@plt>
mov    $0x0,%al
call   10a0 <get_cur_time@plt>
movsd  %xmm0,-0x40(%rbp)
movsd  -0x40(%rbp),%xmm0
subsd  -0x38(%rbp),%xmm0
lea    0xc7d(%rip),%rdi
mov    $0x1,%al
call   1070 <printf@plt>
mov    $0x0,%al
call   10a0 <get_cur_time@plt>
movsd  %xmm0,-0x38(%rbp)
mov    -0x14(%rbp),%edi
mov    -0x20(%rbp),%rsi
mov    -0x28(%rbp),%rdx
mov    -0x30(%rbp),%rcx
mov    -0x18(%rbp),%r8d
call   1080 <matmatkji@plt>
mov    $0x0,%al
call   10a0 <get_cur_time@plt>
movsd  %xmm0,-0x40(%rbp)
movsd  -0x40(%rbp),%xmm0
subsd  -0x38(%rbp),%xmm0
lea    0xc4f(%rip),%rdi
mov    $0x1,%al
call   1070 <printf@plt>
mov    -0x20(%rbp),%rdi
call   1040 <free@plt>
mov    -0x28(%rbp),%rdi
call   1040 <free@plt>
mov    -0x30(%rbp),%rdi
call   1040 <free@plt>
xor    %eax,%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %r15
push   %r14
push   %rbx
sub    $0x10,%rsp
xor    %edi,%edi
call   10c0 <time@plt>
mov    %eax,%edi
call   10a0 <srand@plt>
mov    $0xf4240,%edi
call   10d0 <malloc@plt>
mov    %rax,%r14
mov    $0xf4240,%edi
call   10d0 <malloc@plt>
mov    %rax,%r15
mov    $0xf4240,%edi
call   10d0 <malloc@plt>
mov    %rax,%rbx
mov    $0xa,%edi
call   1050 <putchar@plt>
mov    $0x1f4,%edi
mov    %r14,%rsi
mov    %r15,%rdx
mov    %rbx,%rcx
mov    $0x64,%r8d
call   1070 <randomMatrix@plt>
xor    %eax,%eax
call   10b0 <get_cur_time@plt>
movsd  %xmm0,0x8(%rsp)
mov    $0x1f4,%edi
mov    %r14,%rsi
mov    %r15,%rdx
mov    %rbx,%rcx
mov    $0x64,%r8d
call   1060 <matmatijk@plt>
xor    %eax,%eax
call   10b0 <get_cur_time@plt>
subsd  0x8(%rsp),%xmm0
lea    0xd85(%rip),%rdi
mov    $0x1,%al
call   1080 <printf@plt>
xor    %eax,%eax
call   10b0 <get_cur_time@plt>
movsd  %xmm0,0x8(%rsp)
mov    $0x1f4,%edi
mov    %r14,%rsi
mov    %r15,%rdx
mov    %rbx,%rcx
mov    $0x64,%r8d
call   10e0 <matmatjik@plt>
xor    %eax,%eax
call   10b0 <get_cur_time@plt>
subsd  0x8(%rsp),%xmm0
lea    0xd5e(%rip),%rdi
mov    $0x1,%al
call   1080 <printf@plt>
xor    %eax,%eax
call   10b0 <get_cur_time@plt>
movsd  %xmm0,0x8(%rsp)
mov    $0x1f4,%edi
mov    %r14,%rsi
mov    %r15,%rdx
mov    %rbx,%rcx
mov    $0x64,%r8d
call   1100 <matmatikj@plt>
xor    %eax,%eax
call   10b0 <get_cur_time@plt>
subsd  0x8(%rsp),%xmm0
lea    0xd37(%rip),%rdi
mov    $0x1,%al
call   1080 <printf@plt>
xor    %eax,%eax
call   10b0 <get_cur_time@plt>
movsd  %xmm0,0x8(%rsp)
mov    $0x1f4,%edi
mov    %r14,%rsi
mov    %r15,%rdx
mov    %rbx,%rcx
mov    $0x64,%r8d
call   1030 <matmatjki@plt>
xor    %eax,%eax
call   10b0 <get_cur_time@plt>
subsd  0x8(%rsp),%xmm0
lea    0xd10(%rip),%rdi
mov    $0x1,%al
call   1080 <printf@plt>
xor    %eax,%eax
call   10b0 <get_cur_time@plt>
movsd  %xmm0,0x8(%rsp)
mov    $0x1f4,%edi
mov    %r14,%rsi
mov    %r15,%rdx
mov    %rbx,%rcx
mov    $0x64,%r8d
call   10f0 <matmatkij@plt>
xor    %eax,%eax
call   10b0 <get_cur_time@plt>
subsd  0x8(%rsp),%xmm0
lea    0xce9(%rip),%rdi
mov    $0x1,%al
call   1080 <printf@plt>
xor    %eax,%eax
call   10b0 <get_cur_time@plt>
movsd  %xmm0,0x8(%rsp)
mov    $0x1f4,%edi
mov    %r14,%rsi
mov    %r15,%rdx
mov    %rbx,%rcx
mov    $0x64,%r8d
call   1090 <matmatkji@plt>
xor    %eax,%eax
call   10b0 <get_cur_time@plt>
subsd  0x8(%rsp),%xmm0
lea    0xcc2(%rip),%rdi
mov    $0x1,%al
call   1080 <printf@plt>
mov    %r14,%rdi
call   1040 <free@plt>
mov    %r15,%rdi
call   1040 <free@plt>
mov    %rbx,%rdi
call   1040 <free@plt>
xor    %eax,%eax
add    $0x10,%rsp
pop    %rbx
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
@.str = [2 x i8] c"\0A\00"
@.str.1 = [26 x i8] c"IJK - Elapsed time: %lfs\0A\00"
@.str.2 = [26 x i8] c"JIK - Elapsed time: %lfs\0A\00"
@.str.3 = [26 x i8] c"IKJ - Elapsed time: %lfs\0A\00"
@.str.4 = [26 x i8] c"JKI - Elapsed time: %lfs\0A\00"
@.str.5 = [26 x i8] c"KIJ - Elapsed time: %lfs\0A\00"
@.str.6 = [26 x i8] c"KJI - Elapsed time: %lfs\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 float**
%9 = alloca float**
%10 = alloca float**
%11 = alloca double
%12 = alloca double
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
%13 = call i64 @time(i32* null)
%14 = trunc i64 %13 to i32
%15 = call i32 @srand(i32 %14)
store i32 500, i32* %6
store i32 100, i32* %7
store float** null, float*** %8
store float** null, float*** %9
store float** null, float*** %10
%16 = load i32, i32* %6
%17 = load i32, i32* %6
%18 = mul nsw i32 %16, %17
%19 = sext i32 %18 to i64
%20 = mul i64 %19, 4
%21 = trunc i64 %20 to i32
%22 = call i64 @malloc(i32 %21)
%23 = inttoptr i64 %22 to float**
store float** %23, float*** %8
%24 = load i32, i32* %6
%25 = load i32, i32* %6
%26 = mul nsw i32 %24, %25
%27 = sext i32 %26 to i64
%28 = mul i64 %27, 4
%29 = trunc i64 %28 to i32
%30 = call i64 @malloc(i32 %29)
%31 = inttoptr i64 %30 to float**
store float** %31, float*** %9
%32 = load i32, i32* %6
%33 = load i32, i32* %6
%34 = mul nsw i32 %32, %33
%35 = sext i32 %34 to i64
%36 = mul i64 %35, 4
%37 = trunc i64 %36 to i32
%38 = call i64 @malloc(i32 %37)
%39 = inttoptr i64 %38 to float**
store float** %39, float*** %10
%40 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%41 = load i32, i32* %6
%42 = load i32, i32* %6
%43 = zext i32 %42 to i64
%44 = load float**, float*** %8
%45 = bitcast float** %44 to float*
%46 = bitcast float* %45 to float**
%47 = load i32, i32* %6
%48 = zext i32 %47 to i64
%49 = load float**, float*** %9
%50 = bitcast float** %49 to float*
%51 = bitcast float* %50 to float**
%52 = load i32, i32* %6
%53 = zext i32 %52 to i64
%54 = load float**, float*** %10
%55 = bitcast float** %54 to float*
%56 = bitcast float* %55 to float**
%57 = load i32, i32* %7
%58 = call i32 @randomMatrix(i32 %41, float** %46, float** %51, float** %56, i32 %57)
%59 = call double (...) @get_cur_time()
store double %59, double* %11
%60 = load i32, i32* %6
%61 = load i32, i32* %6
%62 = zext i32 %61 to i64
%63 = load float**, float*** %8
%64 = bitcast float** %63 to float*
%65 = bitcast float* %64 to float**
%66 = load i32, i32* %6
%67 = zext i32 %66 to i64
%68 = load float**, float*** %9
%69 = bitcast float** %68 to float*
%70 = bitcast float* %69 to float**
%71 = load i32, i32* %6
%72 = zext i32 %71 to i64
%73 = load float**, float*** %10
%74 = bitcast float** %73 to float*
%75 = bitcast float* %74 to float**
%76 = load i32, i32* %7
%77 = call i32 @matmatijk(i32 %60, float** %65, float** %70, float** %75, i32 %76)
%78 = call double (...) @get_cur_time()
store double %78, double* %12
%79 = load double, double* %12
%80 = load double, double* %11
%81 = fsub double %79, %80
%82 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.1, i64 0, i64 0), double %81)
%83 = call double (...) @get_cur_time()
store double %83, double* %11
%84 = load i32, i32* %6
%85 = load i32, i32* %6
%86 = zext i32 %85 to i64
%87 = load float**, float*** %8
%88 = bitcast float** %87 to float*
%89 = bitcast float* %88 to float**
%90 = load i32, i32* %6
%91 = zext i32 %90 to i64
%92 = load float**, float*** %9
%93 = bitcast float** %92 to float*
%94 = bitcast float* %93 to float**
%95 = load i32, i32* %6
%96 = zext i32 %95 to i64
%97 = load float**, float*** %10
%98 = bitcast float** %97 to float*
%99 = bitcast float* %98 to float**
%100 = load i32, i32* %7
%101 = call i32 @matmatjik(i32 %84, float** %89, float** %94, float** %99, i32 %100)
%102 = call double (...) @get_cur_time()
store double %102, double* %12
%103 = load double, double* %12
%104 = load double, double* %11
%105 = fsub double %103, %104
%106 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.2, i64 0, i64 0), double %105)
%107 = call double (...) @get_cur_time()
store double %107, double* %11
%108 = load i32, i32* %6
%109 = load i32, i32* %6
%110 = zext i32 %109 to i64
%111 = load float**, float*** %8
%112 = bitcast float** %111 to float*
%113 = bitcast float* %112 to float**
%114 = load i32, i32* %6
%115 = zext i32 %114 to i64
%116 = load float**, float*** %9
%117 = bitcast float** %116 to float*
%118 = bitcast float* %117 to float**
%119 = load i32, i32* %6
%120 = zext i32 %119 to i64
%121 = load float**, float*** %10
%122 = bitcast float** %121 to float*
%123 = bitcast float* %122 to float**
%124 = load i32, i32* %7
%125 = call i32 @matmatikj(i32 %108, float** %113, float** %118, float** %123, i32 %124)
%126 = call double (...) @get_cur_time()
store double %126, double* %12
%127 = load double, double* %12
%128 = load double, double* %11
%129 = fsub double %127, %128
%130 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.3, i64 0, i64 0), double %129)
%131 = call double (...) @get_cur_time()
store double %131, double* %11
%132 = load i32, i32* %6
%133 = load i32, i32* %6
%134 = zext i32 %133 to i64
%135 = load float**, float*** %8
%136 = bitcast float** %135 to float*
%137 = bitcast float* %136 to float**
%138 = load i32, i32* %6
%139 = zext i32 %138 to i64
%140 = load float**, float*** %9
%141 = bitcast float** %140 to float*
%142 = bitcast float* %141 to float**
%143 = load i32, i32* %6
%144 = zext i32 %143 to i64
%145 = load float**, float*** %10
%146 = bitcast float** %145 to float*
%147 = bitcast float* %146 to float**
%148 = load i32, i32* %7
%149 = call i32 @matmatjki(i32 %132, float** %137, float** %142, float** %147, i32 %148)
%150 = call double (...) @get_cur_time()
store double %150, double* %12
%151 = load double, double* %12
%152 = load double, double* %11
%153 = fsub double %151, %152
%154 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.4, i64 0, i64 0), double %153)
%155 = call double (...) @get_cur_time()
store double %155, double* %11
%156 = load i32, i32* %6
%157 = load i32, i32* %6
%158 = zext i32 %157 to i64
%159 = load float**, float*** %8
%160 = bitcast float** %159 to float*
%161 = bitcast float* %160 to float**
%162 = load i32, i32* %6
%163 = zext i32 %162 to i64
%164 = load float**, float*** %9
%165 = bitcast float** %164 to float*
%166 = bitcast float* %165 to float**
%167 = load i32, i32* %6
%168 = zext i32 %167 to i64
%169 = load float**, float*** %10
%170 = bitcast float** %169 to float*
%171 = bitcast float* %170 to float**
%172 = load i32, i32* %7
%173 = call i32 @matmatkij(i32 %156, float** %161, float** %166, float** %171, i32 %172)
%174 = call double (...) @get_cur_time()
store double %174, double* %12
%175 = load double, double* %12
%176 = load double, double* %11
%177 = fsub double %175, %176
%178 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.5, i64 0, i64 0), double %177)
%179 = call double (...) @get_cur_time()
store double %179, double* %11
%180 = load i32, i32* %6
%181 = load i32, i32* %6
%182 = zext i32 %181 to i64
%183 = load float**, float*** %8
%184 = bitcast float** %183 to float*
%185 = bitcast float* %184 to float**
%186 = load i32, i32* %6
%187 = zext i32 %186 to i64
%188 = load float**, float*** %9
%189 = bitcast float** %188 to float*
%190 = bitcast float* %189 to float**
%191 = load i32, i32* %6
%192 = zext i32 %191 to i64
%193 = load float**, float*** %10
%194 = bitcast float** %193 to float*
%195 = bitcast float* %194 to float**
%196 = load i32, i32* %7
%197 = call i32 @matmatkji(i32 %180, float** %185, float** %190, float** %195, i32 %196)
%198 = call double (...) @get_cur_time()
store double %198, double* %12
%199 = load double, double* %12
%200 = load double, double* %11
%201 = fsub double %199, %200
%202 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.6, i64 0, i64 0), double %201)
%203 = load float**, float*** %8
%204 = call i32 @free(float** %203)
%205 = load float**, float*** %9
%206 = call i32 @free(float** %205)
%207 = load float**, float*** %10
%208 = call i32 @free(float** %207)
ret i32 0
}

LLVM IR (-O2):
@.str.1 = [26 x i8] c"IJK - Elapsed time: %lfs\0A\00"
@.str.2 = [26 x i8] c"JIK - Elapsed time: %lfs\0A\00"
@.str.3 = [26 x i8] c"IKJ - Elapsed time: %lfs\0A\00"
@.str.4 = [26 x i8] c"JKI - Elapsed time: %lfs\0A\00"
@.str.5 = [26 x i8] c"KIJ - Elapsed time: %lfs\0A\00"
@.str.6 = [26 x i8] c"KJI - Elapsed time: %lfs\0A\00"
define i32 @main(i32 %0, i8** nocapture readnone %1) {
%3 = tail call i64 @time(i32* null)
%4 = trunc i64 %3 to i32
%5 = tail call i32 @srand(i32 %4)
%6 = tail call i64 @malloc(i32 1000000)
%7 = inttoptr i64 %6 to float**
%8 = tail call i64 @malloc(i32 1000000)
%9 = inttoptr i64 %8 to float**
%10 = tail call i64 @malloc(i32 1000000)
%11 = inttoptr i64 %10 to float**
%12 = tail call i32 @putchar(i32 10)
%13 = tail call i32 @randomMatrix(i32 500, float** %7, float** %9, float** %11, i32 100)
%14 = tail call double (...) @get_cur_time()
%15 = tail call i32 @matmatijk(i32 500, float** %7, float** %9, float** %11, i32 100)
%16 = tail call double (...) @get_cur_time()
%17 = fsub double %16, %14
%18 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([26 x i8], [26 x i8]* @.str.1, i64 0, i64 0), double %17)
%19 = tail call double (...) @get_cur_time()
%20 = tail call i32 @matmatjik(i32 500, float** %7, float** %9, float** %11, i32 100)
%21 = tail call double (...) @get_cur_time()
%22 = fsub double %21, %19
%23 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([26 x i8], [26 x i8]* @.str.2, i64 0, i64 0), double %22)
%24 = tail call double (...) @get_cur_time()
%25 = tail call i32 @matmatikj(i32 500, float** %7, float** %9, float** %11, i32 100)
%26 = tail call double (...) @get_cur_time()
%27 = fsub double %26, %24
%28 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([26 x i8], [26 x i8]* @.str.3, i64 0, i64 0), double %27)
%29 = tail call double (...) @get_cur_time()
%30 = tail call i32 @matmatjki(i32 500, float** %7, float** %9, float** %11, i32 100)
%31 = tail call double (...) @get_cur_time()
%32 = fsub double %31, %29
%33 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([26 x i8], [26 x i8]* @.str.4, i64 0, i64 0), double %32)
%34 = tail call double (...) @get_cur_time()
%35 = tail call i32 @matmatkij(i32 500, float** %7, float** %9, float** %11, i32 100)
%36 = tail call double (...) @get_cur_time()
%37 = fsub double %36, %34
%38 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([26 x i8], [26 x i8]* @.str.5, i64 0, i64 0), double %37)
%39 = tail call double (...) @get_cur_time()
%40 = tail call i32 @matmatkji(i32 500, float** %7, float** %9, float** %11, i32 100)
%41 = tail call double (...) @get_cur_time()
%42 = fsub double %41, %39
%43 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([26 x i8], [26 x i8]* @.str.6, i64 0, i64 0), double %42)
%44 = tail call i32 @free(float** %7)
%45 = tail call i32 @free(float** %9)
%46 = tail call i32 @free(float** %11)
ret i32 0
}