#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*/ printf(char *);
int rand();
void invert_matrix() {
  int i, j, k;
  float t1;
  float matrix_1[50][50];
  float matrix_2[50][50];
  printf("sched_tc5: invert_matrix: before first matrix inversion\n");
  for (i = 0; i < 50; i++)
    for (j = 0; j < 50; j++) {
      matrix_1[i][j] = (float)(rand() % 100);
    }
  printf("sched_tc5: invert_matrix: before second matrix inversion\n");
  for (i = 0; i < 50; i++)
    for (j = 0; j < 50; j++)
      if (i == j)
        matrix_2[i][j] = 1;
      else
        matrix_2[i][j] = 0;
  printf("sched_tc5: invert_matrix: before form identity matrix\n");
  for (i = 0; i < 50; i++) {
    t1 = matrix_1[i][j];
    for (j = 0; j < 50; j++) {
      matrix_1[i][j] /= t1;
      matrix_2[i][j] /= t1;
    }
    for (j = 0; j < 50; j++)
      if (i != j) {
        t1 = -matrix_1[j][i];
        for (k = 0; k < 50; k++) {
          matrix_1[j][k] += (matrix_1[i][k] * t1);
          matrix_2[j][k] += (matrix_2[i][k] * t1);
        }
      }
  }
  printf("sched_tc5: invert_matrix: after form identity matrix\n");
}


x86 assembly (clang, -O0):
<invert_matrix>:
push   %rbp
mov    %rsp,%rbp
sub    $0x4e30,%rsp
lea    0xed2(%rip),%rdi
call   1030 <printf@plt>
movl   $0x0,-0x4(%rbp)
cmpl   $0x32,-0x4(%rbp)
jge    11ab <invert_matrix+0x8b>
movl   $0x0,-0x8(%rbp)
cmpl   $0x32,-0x8(%rbp)
jge    1198 <invert_matrix+0x78>
mov    $0x0,%al
call   1040 <rand@plt>
mov    $0x64,%ecx
cltd
idiv   %ecx
cvtsi2ss %edx,%xmm0
movslq -0x4(%rbp),%rcx
lea    -0x2720(%rbp),%rax
imul   $0xc8,%rcx,%rcx
add    %rcx,%rax
movslq -0x8(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    114f <invert_matrix+0x2f>
jmp    119d <invert_matrix+0x7d>
mov    -0x4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4(%rbp)
jmp    113e <invert_matrix+0x1e>
lea    0xe8b(%rip),%rdi
call   1030 <printf@plt>
movl   $0x0,-0x4(%rbp)
cmpl   $0x32,-0x4(%rbp)
jge    1257 <invert_matrix+0x137>
movl   $0x0,-0x8(%rbp)
cmpl   $0x32,-0x8(%rbp)
jge    1244 <invert_matrix+0x124>
mov    -0x4(%rbp),%eax
cmp    -0x8(%rbp),%eax
jne    1210 <invert_matrix+0xf0>
movslq -0x4(%rbp),%rcx
lea    -0x4e30(%rbp),%rax
imul   $0xc8,%rcx,%rcx
add    %rcx,%rax
movslq -0x8(%rbp),%rcx
movss  0xdfa(%rip),%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    1231 <invert_matrix+0x111>
movslq -0x4(%rbp),%rcx
lea    -0x4e30(%rbp),%rax
imul   $0xc8,%rcx,%rcx
add    %rcx,%rax
movslq -0x8(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    1236 <invert_matrix+0x116>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    11cf <invert_matrix+0xaf>
jmp    1249 <invert_matrix+0x129>
mov    -0x4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4(%rbp)
jmp    11be <invert_matrix+0x9e>
lea    0xe19(%rip),%rdi
call   1030 <printf@plt>
movl   $0x0,-0x4(%rbp)
cmpl   $0x32,-0x4(%rbp)
jge    1441 <invert_matrix+0x321>
movslq -0x4(%rbp),%rcx
lea    -0x2720(%rbp),%rax
imul   $0xc8,%rcx,%rcx
add    %rcx,%rax
movslq -0x8(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x10(%rbp)
movl   $0x0,-0x8(%rbp)
cmpl   $0x32,-0x8(%rbp)
jge    130e <invert_matrix+0x1ee>
movss  -0x10(%rbp),%xmm1
movslq -0x4(%rbp),%rcx
lea    -0x2720(%rbp),%rax
imul   $0xc8,%rcx,%rcx
add    %rcx,%rax
movslq -0x8(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x10(%rbp),%xmm1
movslq -0x4(%rbp),%rcx
lea    -0x4e30(%rbp),%rax
imul   $0xc8,%rcx,%rcx
add    %rcx,%rax
movslq -0x8(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    129e <invert_matrix+0x17e>
movl   $0x0,-0x8(%rbp)
cmpl   $0x32,-0x8(%rbp)
jge    142e <invert_matrix+0x30e>
mov    -0x4(%rbp),%eax
cmp    -0x8(%rbp),%eax
je     141b <invert_matrix+0x2fb>
movslq -0x8(%rbp),%rcx
lea    -0x2720(%rbp),%rax
imul   $0xc8,%rcx,%rcx
add    %rcx,%rax
movslq -0x4(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x10(%rbp)
movl   $0x0,-0xc(%rbp)
cmpl   $0x32,-0xc(%rbp)
jge    1416 <invert_matrix+0x2f6>
movslq -0x4(%rbp),%rcx
lea    -0x2720(%rbp),%rax
imul   $0xc8,%rcx,%rcx
add    %rcx,%rax
movslq -0xc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x10(%rbp),%xmm2
movslq -0x8(%rbp),%rcx
lea    -0x2720(%rbp),%rax
imul   $0xc8,%rcx,%rcx
add    %rcx,%rax
movslq -0xc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movslq -0x4(%rbp),%rcx
lea    -0x4e30(%rbp),%rax
imul   $0xc8,%rcx,%rcx
add    %rcx,%rax
movslq -0xc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x10(%rbp),%xmm2
movslq -0x8(%rbp),%rcx
lea    -0x4e30(%rbp),%rax
imul   $0xc8,%rcx,%rcx
add    %rcx,%rax
movslq -0xc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1362 <invert_matrix+0x242>
jmp    141b <invert_matrix+0x2fb>
jmp    1420 <invert_matrix+0x300>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1315 <invert_matrix+0x1f5>
jmp    1433 <invert_matrix+0x313>
mov    -0x4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4(%rbp)
jmp    126a <invert_matrix+0x14a>
lea    0xc66(%rip),%rdi
call   1030 <printf@plt>
add    $0x4e30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<invert_matrix>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x4e28,%rsp
lea    0xee8(%rip),%rdi
call   1030 <puts@plt>
mov    %rsp,%r15
xor    %r14d,%r14d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xor    %eax,%eax
call   1040 <rand@plt>
cltq
imul   $0x51eb851f,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x25,%rcx
add    %edx,%ecx
imul   $0x64,%ecx,%ecx
sub    %ecx,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,(%r15,%rbx,4)
add    $0x1,%rbx
cmp    $0x32,%rbx
jne    1160 <invert_matrix+0x40>
add    $0x1,%r14
add    $0xc8,%r15
cmp    $0x32,%r14
jne    1150 <invert_matrix+0x30>
lea    0xea7(%rip),%rdi
call   1030 <puts@plt>
lea    0x2714(%rsp),%rax
xor    %ecx,%ecx
movss  0xe38(%rip),%xmm0
jmp    11e0 <invert_matrix+0xc0>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rcx
add    $0xc8,%rax
cmp    $0x32,%rcx
je     1221 <invert_matrix+0x101>
xor    %edx,%edx
jmp    11ff <invert_matrix+0xdf>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  %xmm1,(%rax,%rdx,4)
add    $0x2,%rdx
cmp    $0x32,%rdx
je     11d0 <invert_matrix+0xb0>
movaps %xmm0,%xmm1
cmp    %rdx,%rcx
je     120a <invert_matrix+0xea>
xorps  %xmm1,%xmm1
movss  %xmm1,-0x4(%rax,%rdx,4)
lea    0x1(%rdx),%rsi
movaps %xmm0,%xmm1
cmp    %rsi,%rcx
je     11f0 <invert_matrix+0xd0>
xorps  %xmm1,%xmm1
jmp    11f0 <invert_matrix+0xd0>
lea    0xe69(%rip),%rdi
call   1030 <puts@plt>
mov    %rsp,%rdi
lea    0x2710(%rsp),%rsi
xor    %r12d,%r12d
movaps 0xdce(%rip),%xmm0
jmp    126c <invert_matrix+0x14c>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r12
add    $0xc8,%rdi
add    $0xc8,%rsi
cmp    $0x32,%r12
je     1448 <invert_matrix+0x328>
imul   $0xc8,%r12,%rax
lea    (%rsp,%rax,1),%r10
lea    (%rsp,%rax,1),%r11
add    $0xc8,%r11
lea    0x2710(%rsp,%rax,1),%r14
lea    0x27d8(%rsp,%rax,1),%r15
movss  0xc8(%rsp,%rax,1),%xmm1
movaps %xmm1,%xmm2
shufps $0x0,%xmm1,%xmm2
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups (%rdi,%rcx,4),%xmm3
divps  %xmm2,%xmm3
movups %xmm3,(%rdi,%rcx,4)
movups (%rsi,%rcx,4),%xmm3
divps  %xmm2,%xmm3
movups %xmm3,(%rsi,%rcx,4)
add    $0x4,%rcx
cmp    $0x30,%rcx
jne    12b0 <invert_matrix+0x190>
movss  0xc0(%rsp,%rax,1),%xmm2
divss  %xmm1,%xmm2
movss  %xmm2,0xc0(%rsp,%rax,1)
movss  0x27d0(%rsp,%rax,1),%xmm2
divss  %xmm1,%xmm2
movss  %xmm2,0x27d0(%rsp,%rax,1)
movss  0xc4(%rsp,%rax,1),%xmm2
divss  %xmm1,%xmm2
movss  %xmm2,0xc4(%rsp,%rax,1)
movss  0x27d4(%rsp,%rax,1),%xmm2
divss  %xmm1,%xmm2
movss  %xmm2,0x27d4(%rsp,%rax,1)
lea    0x2710(%rsp),%rbx
mov    %rsp,%rax
xor    %edx,%edx
jmp    135a <invert_matrix+0x23a>
nopw   0x0(%rax,%rax,1)
add    $0xc8,%rax
add    $0xc8,%rbx
mov    %r13,%rdx
cmp    $0x32,%r13
je     1250 <invert_matrix+0x130>
lea    0x1(%rdx),%r13
cmp    %rdx,%r12
je     1340 <invert_matrix+0x220>
imul   $0xc8,%r13,%rcx
lea    (%rsp,%rcx,1),%rbp
add    $0x2710,%rbp
imul   $0xc8,%rdx,%rdx
lea    (%rsp,%rdx,1),%r8
add    $0x2710,%r8
add    %rsp,%rcx
add    %rsp,%rdx
movss  (%rdx,%r12,4),%xmm1
xorps  %xmm0,%xmm1
cmp    %r11,%rdx
setb   %dl
cmp    %rcx,%r10
setb   %r9b
cmp    %r15,%r8
setb   %cl
cmp    %rbp,%r14
setb   %bpl
test   %r9b,%dl
jne    1405 <invert_matrix+0x2e5>
mov    $0x0,%edx
and    %bpl,%cl
jne    1407 <invert_matrix+0x2e7>
movaps %xmm1,%xmm2
shufps $0x0,%xmm1,%xmm2
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movups (%rdi,%rdx,4),%xmm3
movups (%rax,%rdx,4),%xmm4
mulps  %xmm2,%xmm3
addps  %xmm4,%xmm3
movups %xmm3,(%rax,%rdx,4)
movups (%rsi,%rdx,4),%xmm3
movups (%rbx,%rdx,4),%xmm4
mulps  %xmm2,%xmm3
addps  %xmm4,%xmm3
movups %xmm3,(%rbx,%rdx,4)
add    $0x4,%rdx
cmp    $0x30,%rdx
jne    13d0 <invert_matrix+0x2b0>
mov    $0x30,%edx
jmp    1407 <invert_matrix+0x2e7>
xor    %edx,%edx
shl    $0x2,%rdx
nopl   0x0(%rax,%rax,1)
movss  (%rdi,%rdx,1),%xmm2
mulss  %xmm1,%xmm2
addss  (%rax,%rdx,1),%xmm2
movss  (%rsi,%rdx,1),%xmm3
mulss  %xmm1,%xmm3
addss  (%rbx,%rdx,1),%xmm3
movss  %xmm2,(%rax,%rdx,1)
movss  %xmm3,(%rbx,%rdx,1)
add    $0x4,%rdx
cmp    $0xc8,%rdx
jne    1410 <invert_matrix+0x2f0>
jmp    1340 <invert_matrix+0x220>
lea    0xc78(%rip),%rdi
add    $0x4e28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <puts@plt>

LLVM IR (-O0):
@.str = [57 x i8] c"sched_tc5: invert_matrix: before first matrix inversion\0A\00"
@.str.1 = [58 x i8] c"sched_tc5: invert_matrix: before second matrix inversion\0A\00"
@.str.2 = [55 x i8] c"sched_tc5: invert_matrix: before form identity matrix\0A\00"
@.str.3 = [54 x i8] c"sched_tc5: invert_matrix: after form identity matrix\0A\00"
define void @invert_matrix() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i32
%4 = alloca float
%5 = alloca [50 x [50 x float]]
%6 = alloca [50 x [50 x float]]
%7 = call i32 @printf(i8* getelementptr inbounds ([57 x i8], [57 x i8]* @.str, i64 0, i64 0))
store i32 0, i32* %1
br label %8
8: ; preds = %29, %0
%9 = load i32, i32* %1
%10 = icmp slt i32 %9, 50
br i1 %10, label %11, label %32
11: ; preds = %8
store i32 0, i32* %2
br label %12
12: ; preds = %25, %11
%13 = load i32, i32* %2
%14 = icmp slt i32 %13, 50
br i1 %14, label %15, label %28
15: ; preds = %12
%16 = call i32 (...) @rand()
%17 = srem i32 %16, 100
%18 = sitofp i32 %17 to float
%19 = load i32, i32* %1
%20 = sext i32 %19 to i64
%21 = getelementptr inbounds [50 x [50 x float]], [50 x [50 x float]]* %5, i64 0, i64 %20
%22 = load i32, i32* %2
%23 = sext i32 %22 to i64
%24 = getelementptr inbounds [50 x float], [50 x float]* %21, i64 0, i64 %23
store float %18, float* %24
br label %25
25: ; preds = %15
%26 = load i32, i32* %2
%27 = add nsw i32 %26, 1
store i32 %27, i32* %2
br label %12
28: ; preds = %12
br label %29
29: ; preds = %28
%30 = load i32, i32* %1
%31 = add nsw i32 %30, 1
store i32 %31, i32* %1
br label %8
32: ; preds = %8
%33 = call i32 @printf(i8* getelementptr inbounds ([58 x i8], [58 x i8]* @.str.1, i64 0, i64 0))
store i32 0, i32* %1
br label %34
34: ; preds = %64, %32
%35 = load i32, i32* %1
%36 = icmp slt i32 %35, 50
br i1 %36, label %37, label %67
37: ; preds = %34
store i32 0, i32* %2
br label %38
38: ; preds = %60, %37
%39 = load i32, i32* %2
%40 = icmp slt i32 %39, 50
br i1 %40, label %41, label %63
41: ; preds = %38
%42 = load i32, i32* %1
%43 = load i32, i32* %2
%44 = icmp eq i32 %42, %43
br i1 %44, label %45, label %52
45: ; preds = %41
%46 = load i32, i32* %1
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds [50 x [50 x float]], [50 x [50 x float]]* %6, i64 0, i64 %47
%49 = load i32, i32* %2
%50 = sext i32 %49 to i64
%51 = getelementptr inbounds [50 x float], [50 x float]* %48, i64 0, i64 %50
store float 1.000000e+00, float* %51
br label %59
52: ; preds = %41
%53 = load i32, i32* %1
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds [50 x [50 x float]], [50 x [50 x float]]* %6, i64 0, i64 %54
%56 = load i32, i32* %2
%57 = sext i32 %56 to i64
%58 = getelementptr inbounds [50 x float], [50 x float]* %55, i64 0, i64 %57
store float 0.000000e+00, float* %58
br label %59
59: ; preds = %52, %45
br label %60
60: ; preds = %59
%61 = load i32, i32* %2
%62 = add nsw i32 %61, 1
store i32 %62, i32* %2
br label %38
63: ; preds = %38
br label %64
64: ; preds = %63
%65 = load i32, i32* %1
%66 = add nsw i32 %65, 1
store i32 %66, i32* %1
br label %34
67: ; preds = %34
%68 = call i32 @printf(i8* getelementptr inbounds ([55 x i8], [55 x i8]* @.str.2, i64 0, i64 0))
store i32 0, i32* %1
br label %69
69: ; preds = %167, %67
%70 = load i32, i32* %1
%71 = icmp slt i32 %70, 50
br i1 %71, label %72, label %170
72: ; preds = %69
%73 = load i32, i32* %1
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds [50 x [50 x float]], [50 x [50 x float]]* %5, i64 0, i64 %74
%76 = load i32, i32* %2
%77 = sext i32 %76 to i64
%78 = getelementptr inbounds [50 x float], [50 x float]* %75, i64 0, i64 %77
%79 = load float, float* %78
store float %79, float* %4
store i32 0, i32* %2
br label %80
80: ; preds = %102, %72
%81 = load i32, i32* %2
%82 = icmp slt i32 %81, 50
br i1 %82, label %83, label %105
83: ; preds = %80
%84 = load float, float* %4
%85 = load i32, i32* %1
%86 = sext i32 %85 to i64
%87 = getelementptr inbounds [50 x [50 x float]], [50 x [50 x float]]* %5, i64 0, i64 %86
%88 = load i32, i32* %2
%89 = sext i32 %88 to i64
%90 = getelementptr inbounds [50 x float], [50 x float]* %87, i64 0, i64 %89
%91 = load float, float* %90
%92 = fdiv float %91, %84
store float %92, float* %90
%93 = load float, float* %4
%94 = load i32, i32* %1
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds [50 x [50 x float]], [50 x [50 x float]]* %6, i64 0, i64 %95
%97 = load i32, i32* %2
%98 = sext i32 %97 to i64
%99 = getelementptr inbounds [50 x float], [50 x float]* %96, i64 0, i64 %98
%100 = load float, float* %99
%101 = fdiv float %100, %93
store float %101, float* %99
br label %102
102: ; preds = %83
%103 = load i32, i32* %2
%104 = add nsw i32 %103, 1
store i32 %104, i32* %2
br label %80
105: ; preds = %80
store i32 0, i32* %2
br label %106
106: ; preds = %163, %105
%107 = load i32, i32* %2
%108 = icmp slt i32 %107, 50
br i1 %108, label %109, label %166
109: ; preds = %106
%110 = load i32, i32* %1
%111 = load i32, i32* %2
%112 = icmp ne i32 %110, %111
br i1 %112, label %113, label %162
113: ; preds = %109
%114 = load i32, i32* %2
%115 = sext i32 %114 to i64
%116 = getelementptr inbounds [50 x [50 x float]], [50 x [50 x float]]* %5, i64 0, i64 %115
%117 = load i32, i32* %1
%118 = sext i32 %117 to i64
%119 = getelementptr inbounds [50 x float], [50 x float]* %116, i64 0, i64 %118
%120 = load float, float* %119
%121 = fneg float %120
store float %121, float* %4
store i32 0, i32* %3
br label %122
122: ; preds = %158, %113
%123 = load i32, i32* %3
%124 = icmp slt i32 %123, 50
br i1 %124, label %125, label %161
125: ; preds = %122
%126 = load i32, i32* %1
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds [50 x [50 x float]], [50 x [50 x float]]* %5, i64 0, i64 %127
%129 = load i32, i32* %3
%130 = sext i32 %129 to i64
%131 = getelementptr inbounds [50 x float], [50 x float]* %128, i64 0, i64 %130
%132 = load float, float* %131
%133 = load float, float* %4
%134 = load i32, i32* %2
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds [50 x [50 x float]], [50 x [50 x float]]* %5, i64 0, i64 %135
%137 = load i32, i32* %3
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds [50 x float], [50 x float]* %136, i64 0, i64 %138
%140 = load float, float* %139
%141 = call float @llvm.fmuladd.f32(float %132, float %133, float %140)
store float %141, float* %139
%142 = load i32, i32* %1
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds [50 x [50 x float]], [50 x [50 x float]]* %6, i64 0, i64 %143
%145 = load i32, i32* %3
%146 = sext i32 %145 to i64
%147 = getelementptr inbounds [50 x float], [50 x float]* %144, i64 0, i64 %146
%148 = load float, float* %147
%149 = load float, float* %4
%150 = load i32, i32* %2
%151 = sext i32 %150 to i64
%152 = getelementptr inbounds [50 x [50 x float]], [50 x [50 x float]]* %6, i64 0, i64 %151
%153 = load i32, i32* %3
%154 = sext i32 %153 to i64
%155 = getelementptr inbounds [50 x float], [50 x float]* %152, i64 0, i64 %154
%156 = load float, float* %155
%157 = call float @llvm.fmuladd.f32(float %148, float %149, float %156)
store float %157, float* %155
br label %158
158: ; preds = %125
%159 = load i32, i32* %3
%160 = add nsw i32 %159, 1
store i32 %160, i32* %3
br label %122
161: ; preds = %122
br label %162
162: ; preds = %161, %109
br label %163
163: ; preds = %162
%164 = load i32, i32* %2
%165 = add nsw i32 %164, 1
store i32 %165, i32* %2
br label %106
166: ; preds = %106
br label %167
167: ; preds = %166
%168 = load i32, i32* %1
%169 = add nsw i32 %168, 1
store i32 %169, i32* %1
br label %69
170: ; preds = %69
%171 = call i32 @printf(i8* getelementptr inbounds ([54 x i8], [54 x i8]* @.str.3, i64 0, i64 0))
ret void
}

LLVM IR (-O2):
@str = [56 x i8] c"sched_tc5: invert_matrix: before first matrix inversion\00"
@str.4 = [57 x i8] c"sched_tc5: invert_matrix: before second matrix inversion\00"
@str.5 = [54 x i8] c"sched_tc5: invert_matrix: before form identity matrix\00"
@str.6 = [53 x i8] c"sched_tc5: invert_matrix: after form identity matrix\00"
define void @invert_matrix() {
%1 = alloca [50 x [50 x float]]
%2 = alloca [50 x [50 x float]]
%3 = bitcast [50 x [50 x float]]* %1 to i8*
%4 = bitcast [50 x [50 x float]]* %2 to i8*
%5 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([56 x i8], [56 x i8]* @str, i64 0, i64 0))
br label %6
6: ; preds = %0, %16
%7 = phi i64 [ 0, %0 ], [ %17, %16 ]
br label %8
8: ; preds = %6, %8
%9 = phi i64 [ 0, %6 ], [ %14, %8 ]
%10 = tail call i32 (...) @rand()
%11 = srem i32 %10, 100
%12 = sitofp i32 %11 to float
%13 = getelementptr inbounds [50 x [50 x float]], [50 x [50 x float]]* %1, i64 0, i64 %7, i64 %9
store float %12, float* %13
%14 = add nuw nsw i64 %9, 1
%15 = icmp eq i64 %14, 50
br i1 %15, label %16, label %8
16: ; preds = %8
%17 = add nuw nsw i64 %7, 1
%18 = icmp eq i64 %17, 50
br i1 %18, label %19, label %6
19: ; preds = %16
%20 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([57 x i8], [57 x i8]* @str.4, i64 0, i64 0))
br label %21
21: ; preds = %19, %34
%22 = phi i64 [ 0, %19 ], [ %35, %34 ]
br label %23
23: ; preds = %23, %21
%24 = phi i64 [ 0, %21 ], [ %32, %23 ]
%25 = icmp eq i64 %22, %24
%26 = select i1 %25, float 1.000000e+00, float 0.000000e+00
%27 = getelementptr inbounds [50 x [50 x float]], [50 x [50 x float]]* %2, i64 0, i64 %22, i64 %24
store float %26, float* %27
%28 = or i64 %24, 1
%29 = icmp eq i64 %22, %28
%30 = select i1 %29, float 1.000000e+00, float 0.000000e+00
%31 = getelementptr inbounds [50 x [50 x float]], [50 x [50 x float]]* %2, i64 0, i64 %22, i64 %28
store float %30, float* %31
%32 = add nuw nsw i64 %24, 2
%33 = icmp eq i64 %32, 50
br i1 %33, label %34, label %23
34: ; preds = %23
%35 = add nuw nsw i64 %22, 1
%36 = icmp eq i64 %35, 50
br i1 %36, label %37, label %21
37: ; preds = %34
%38 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([54 x i8], [54 x i8]* @str.5, i64 0, i64 0))
br label %39
39: ; preds = %37, %138
%40 = phi i64 [ 0, %37 ], [ %139, %138 ]
%41 = getelementptr [50 x [50 x float]], [50 x [50 x float]]* %1, i64 0, i64 %40, i64 0
%42 = add nuw i64 %40, 1
%43 = getelementptr [50 x [50 x float]], [50 x [50 x float]]* %1, i64 0, i64 %42, i64 0
%44 = getelementptr [50 x [50 x float]], [50 x [50 x float]]* %2, i64 0, i64 %40, i64 0
%45 = getelementptr [50 x [50 x float]], [50 x [50 x float]]* %2, i64 0, i64 %42, i64 0
%46 = getelementptr inbounds [50 x [50 x float]], [50 x [50 x float]]* %1, i64 0, i64 %40, i64 50
%47 = load float, float* %46
%48 = insertelement <4 x float> poison, float %47, i64 0
%49 = shufflevector <4 x float> %48, <4 x float> poison, <4 x i32> zeroinitializer
br label %50
50: ; preds = %50, %39
%51 = phi i64 [ 0, %39 ], [ %62, %50 ]
%52 = getelementptr inbounds [50 x [50 x float]], [50 x [50 x float]]* %1, i64 0, i64 %40, i64 %51
%53 = bitcast float* %52 to <4 x float>*
%54 = load <4 x float>, <4 x float>* %53
%55 = fdiv <4 x float> %54, %49
%56 = bitcast float* %52 to <4 x float>*
store <4 x float> %55, <4 x float>* %56
%57 = getelementptr inbounds [50 x [50 x float]], [50 x [50 x float]]* %2, i64 0, i64 %40, i64 %51
%58 = bitcast float* %57 to <4 x float>*
%59 = load <4 x float>, <4 x float>* %58
%60 = fdiv <4 x float> %59, %49
%61 = bitcast float* %57 to <4 x float>*
store <4 x float> %60, <4 x float>* %61
%62 = add nuw i64 %51, 4
%63 = icmp eq i64 %62, 48
br i1 %63, label %64, label %50
64: ; preds = %50
%65 = getelementptr inbounds [50 x [50 x float]], [50 x [50 x float]]* %1, i64 0, i64 %40, i64 48
%66 = load float, float* %65
%67 = fdiv float %66, %47
store float %67, float* %65
%68 = getelementptr inbounds [50 x [50 x float]], [50 x [50 x float]]* %2, i64 0, i64 %40, i64 48
%69 = load float, float* %68
%70 = fdiv float %69, %47
store float %70, float* %68
%71 = getelementptr inbounds [50 x [50 x float]], [50 x [50 x float]]* %1, i64 0, i64 %40, i64 49
%72 = load float, float* %71
%73 = fdiv float %72, %47
store float %73, float* %71
%74 = getelementptr inbounds [50 x [50 x float]], [50 x [50 x float]]* %2, i64 0, i64 %40, i64 49
%75 = load float, float* %74
%76 = fdiv float %75, %47
store float %76, float* %74
br label %77
77: ; preds = %64, %135
%78 = phi i64 [ %136, %135 ], [ 0, %64 ]
%79 = add nuw i64 %78, 1
%80 = icmp eq i64 %40, %78
br i1 %80, label %135, label %81
81: ; preds = %77
%82 = getelementptr [50 x [50 x float]], [50 x [50 x float]]* %2, i64 0, i64 %79, i64 0
%83 = getelementptr [50 x [50 x float]], [50 x [50 x float]]* %2, i64 0, i64 %78, i64 0
%84 = getelementptr [50 x [50 x float]], [50 x [50 x float]]* %1, i64 0, i64 %79, i64 0
%85 = getelementptr [50 x [50 x float]], [50 x [50 x float]]* %1, i64 0, i64 %78, i64 0
%86 = getelementptr inbounds [50 x [50 x float]], [50 x [50 x float]]* %1, i64 0, i64 %78, i64 %40
%87 = load float, float* %86
%88 = fneg float %87
%89 = icmp ult float* %85, %43
%90 = icmp ult float* %41, %84
%91 = and i1 %89, %90
%92 = icmp ult float* %83, %45
%93 = icmp ult float* %44, %82
%94 = and i1 %92, %93
%95 = or i1 %91, %94
br i1 %95, label %119, label %96
96: ; preds = %81
%97 = insertelement <4 x float> poison, float %88, i64 0
%98 = shufflevector <4 x float> %97, <4 x float> poison, <4 x i32> zeroinitializer
br label %99
99: ; preds = %99, %96
%100 = phi i64 [ 0, %96 ], [ %117, %99 ]
%101 = getelementptr inbounds [50 x [50 x float]], [50 x [50 x float]]* %1, i64 0, i64 %40, i64 %100
%102 = bitcast float* %101 to <4 x float>*
%103 = load <4 x float>, <4 x float>* %102
%104 = getelementptr inbounds [50 x [50 x float]], [50 x [50 x float]]* %1, i64 0, i64 %78, i64 %100
%105 = bitcast float* %104 to <4 x float>*
%106 = load <4 x float>, <4 x float>* %105
%107 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %103, <4 x float> %98, <4 x float> %106)
%108 = bitcast float* %104 to <4 x float>*
store <4 x float> %107, <4 x float>* %108
%109 = getelementptr inbounds [50 x [50 x float]], [50 x [50 x float]]* %2, i64 0, i64 %40, i64 %100
%110 = bitcast float* %109 to <4 x float>*
%111 = load <4 x float>, <4 x float>* %110
%112 = getelementptr inbounds [50 x [50 x float]], [50 x [50 x float]]* %2, i64 0, i64 %78, i64 %100
%113 = bitcast float* %112 to <4 x float>*
%114 = load <4 x float>, <4 x float>* %113
%115 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %111, <4 x float> %98, <4 x float> %114)
%116 = bitcast float* %112 to <4 x float>*
store <4 x float> %115, <4 x float>* %116
%117 = add nuw i64 %100, 4
%118 = icmp eq i64 %117, 48
br i1 %118, label %119, label %99
119: ; preds = %99, %81
%120 = phi i64 [ 0, %81 ], [ 48, %99 ]
br label %121
121: ; preds = %119, %121
%122 = phi i64 [ %133, %121 ], [ %120, %119 ]
%123 = getelementptr inbounds [50 x [50 x float]], [50 x [50 x float]]* %1, i64 0, i64 %40, i64 %122
%124 = load float, float* %123
%125 = getelementptr inbounds [50 x [50 x float]], [50 x [50 x float]]* %1, i64 0, i64 %78, i64 %122
%126 = load float, float* %125
%127 = tail call float @llvm.fmuladd.f32(float %124, float %88, float %126)
store float %127, float* %125
%128 = getelementptr inbounds [50 x [50 x float]], [50 x [50 x float]]* %2, i64 0, i64 %40, i64 %122
%129 = load float, float* %128
%130 = getelementptr inbounds [50 x [50 x float]], [50 x [50 x float]]* %2, i64 0, i64 %78, i64 %122
%131 = load float, float* %130
%132 = tail call float @llvm.fmuladd.f32(float %129, float %88, float %131)
store float %132, float* %130
%133 = add nuw nsw i64 %122, 1
%134 = icmp eq i64 %133, 50
br i1 %134, label %135, label %121
135: ; preds = %121, %77
%136 = add nuw nsw i64 %78, 1
%137 = icmp eq i64 %136, 50
br i1 %137, label %138, label %77
138: ; preds = %135
%139 = add nuw nsw i64 %40, 1
%140 = icmp eq i64 %139, 50
br i1 %140, label %141, label %39
141: ; preds = %138
%142 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([53 x i8], [53 x i8]* @str.6, i64 0, i64 0))
ret void
}