#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 */
float **createMatrix(char, char);
float **createIdentityMatrix(char rows, char cols, float value) {
  float **matrix;
  char i = 0;
  char j = 0;
  matrix = createMatrix(rows, cols);
  for (i = 0; i < rows; i++) {
    for (j = 0; j < cols; j++) {
      if (i == j) {
        matrix[i][j] = value;
      } else {
        matrix[i][j] = 0;
      }
    }
  }
  return matrix;
}


x86 assembly (clang, -O0):
<createIdentityMatrix>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %sil,%al
mov    %dil,%cl
mov    %cl,-0x1(%rbp)
mov    %al,-0x2(%rbp)
movss  %xmm0,-0x8(%rbp)
movb   $0x0,-0x11(%rbp)
movb   $0x0,-0x12(%rbp)
mov    -0x1(%rbp),%al
movsbl %al,%edi
movsbl -0x2(%rbp),%esi
call   1030 <createMatrix@plt>
mov    %rax,-0x10(%rbp)
movb   $0x0,-0x11(%rbp)
movsbl -0x11(%rbp),%eax
movsbl -0x1(%rbp),%ecx
cmp    %ecx,%eax
jge    11db <createIdentityMatrix+0xcb>
movb   $0x0,-0x12(%rbp)
movsbl -0x12(%rbp),%eax
movsbl -0x2(%rbp),%ecx
cmp    %ecx,%eax
jge    11c9 <createIdentityMatrix+0xb9>
movsbl -0x11(%rbp),%eax
movsbl -0x12(%rbp),%ecx
cmp    %ecx,%eax
jne    119d <createIdentityMatrix+0x8d>
movss  -0x8(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsbq -0x11(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbq -0x12(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    11b7 <createIdentityMatrix+0xa7>
mov    -0x10(%rbp),%rax
movsbq -0x11(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbq -0x12(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    11bc <createIdentityMatrix+0xac>
mov    -0x12(%rbp),%al
add    $0x1,%al
mov    %al,-0x12(%rbp)
jmp    115c <createIdentityMatrix+0x4c>
jmp    11ce <createIdentityMatrix+0xbe>
mov    -0x11(%rbp),%al
add    $0x1,%al
mov    %al,-0x11(%rbp)
jmp    1148 <createIdentityMatrix+0x38>
mov    -0x10(%rbp),%rax
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<createIdentityMatrix>:
push   %rbp
push   %r14
push   %rbx
sub    $0x10,%rsp
movss  %xmm0,0xc(%rsp)
mov    %esi,%r14d
mov    %edi,%ebp
call   1030 <createMatrix@plt>
movss  0xc(%rsp),%xmm1
test   %bpl,%bpl
jle    121a <createIdentityMatrix+0x10a>
movzbl %bpl,%r9d
movzbl %r14b,%edx
lea    -0x1(%rdx),%r8
mov    %edx,%edi
and    $0x3,%edi
and    $0xfffffffc,%edx
xor    %ebp,%ebp
jmp    115d <createIdentityMatrix+0x4d>
nop
add    $0x1,%rbp
cmp    %r9,%rbp
je     121a <createIdentityMatrix+0x10a>
test   %r14b,%r14b
jle    1150 <createIdentityMatrix+0x40>
cmp    $0x3,%r8
jae    11b0 <createIdentityMatrix+0xa0>
xor    %esi,%esi
test   %rdi,%rdi
je     1150 <createIdentityMatrix+0x40>
lea    0x0(,%rsi,4),%rbx
add    (%rax,%rbp,8),%rbx
mov    %rbp,%rcx
sub    %rsi,%rcx
xor    %esi,%esi
jmp    119e <createIdentityMatrix+0x8e>
cs nopw 0x0(%rax,%rax,1)
nop
movss  %xmm0,(%rbx,%rsi,4)
add    $0x1,%rsi
cmp    %rsi,%rdi
je     1150 <createIdentityMatrix+0x40>
movaps %xmm1,%xmm0
cmp    %rsi,%rcx
je     1190 <createIdentityMatrix+0x80>
xorps  %xmm0,%xmm0
jmp    1190 <createIdentityMatrix+0x80>
nopl   0x0(%rax,%rax,1)
mov    (%rax,%rbp,8),%rbx
xor    %esi,%esi
jmp    11cf <createIdentityMatrix+0xbf>
nopl   0x0(%rax,%rax,1)
movss  %xmm0,0xc(%rbx,%rsi,4)
add    $0x4,%rsi
cmp    %rdx,%rsi
je     116a <createIdentityMatrix+0x5a>
movaps %xmm1,%xmm0
cmp    %rsi,%rbp
je     11da <createIdentityMatrix+0xca>
xorps  %xmm0,%xmm0
movss  %xmm0,(%rbx,%rsi,4)
lea    0x1(%rsi),%rcx
movaps %xmm1,%xmm0
cmp    %rcx,%rbp
je     11ee <createIdentityMatrix+0xde>
xorps  %xmm0,%xmm0
movss  %xmm0,0x4(%rbx,%rsi,4)
lea    0x2(%rsi),%rcx
movaps %xmm1,%xmm0
cmp    %rcx,%rbp
je     1203 <createIdentityMatrix+0xf3>
xorps  %xmm0,%xmm0
movss  %xmm0,0x8(%rbx,%rsi,4)
lea    0x3(%rsi),%rcx
movaps %xmm1,%xmm0
cmp    %rcx,%rbp
je     11c0 <createIdentityMatrix+0xb0>
xorps  %xmm0,%xmm0
jmp    11c0 <createIdentityMatrix+0xb0>
add    $0x10,%rsp
pop    %rbx
pop    %r14
pop    %rbp
ret

LLVM IR (-O0):
define float** @createIdentityMatrix(i8 signext %0, i8 signext %1, float %2) {
%4 = alloca i8
%5 = alloca i8
%6 = alloca float
%7 = alloca float**
%8 = alloca i8
%9 = alloca i8
store i8 %0, i8* %4
store i8 %1, i8* %5
store float %2, float* %6
store i8 0, i8* %8
store i8 0, i8* %9
%10 = load i8, i8* %4
%11 = load i8, i8* %5
%12 = call float** @createMatrix(i8 signext %10, i8 signext %11)
store float** %12, float*** %7
store i8 0, i8* %8
br label %13
13: ; preds = %56, %3
%14 = load i8, i8* %8
%15 = sext i8 %14 to i32
%16 = load i8, i8* %4
%17 = sext i8 %16 to i32
%18 = icmp slt i32 %15, %17
br i1 %18, label %19, label %59
19: ; preds = %13
store i8 0, i8* %9
br label %20
20: ; preds = %52, %19
%21 = load i8, i8* %9
%22 = sext i8 %21 to i32
%23 = load i8, i8* %5
%24 = sext i8 %23 to i32
%25 = icmp slt i32 %22, %24
br i1 %25, label %26, label %55
26: ; preds = %20
%27 = load i8, i8* %8
%28 = sext i8 %27 to i32
%29 = load i8, i8* %9
%30 = sext i8 %29 to i32
%31 = icmp eq i32 %28, %30
br i1 %31, label %32, label %42
32: ; preds = %26
%33 = load float, float* %6
%34 = load float**, float*** %7
%35 = load i8, i8* %8
%36 = sext i8 %35 to i64
%37 = getelementptr inbounds float*, float** %34, i64 %36
%38 = load float*, float** %37
%39 = load i8, i8* %9
%40 = sext i8 %39 to i64
%41 = getelementptr inbounds float, float* %38, i64 %40
store float %33, float* %41
br label %51
42: ; preds = %26
%43 = load float**, float*** %7
%44 = load i8, i8* %8
%45 = sext i8 %44 to i64
%46 = getelementptr inbounds float*, float** %43, i64 %45
%47 = load float*, float** %46
%48 = load i8, i8* %9
%49 = sext i8 %48 to i64
%50 = getelementptr inbounds float, float* %47, i64 %49
store float 0.000000e+00, float* %50
br label %51
51: ; preds = %42, %32
br label %52
52: ; preds = %51
%53 = load i8, i8* %9
%54 = add i8 %53, 1
store i8 %54, i8* %9
br label %20
55: ; preds = %20
br label %56
56: ; preds = %55
%57 = load i8, i8* %8
%58 = add i8 %57, 1
store i8 %58, i8* %8
br label %13
59: ; preds = %13
%60 = load float**, float*** %7
ret float** %60
}

LLVM IR (-O2):
define float** @createIdentityMatrix(i8 signext %0, i8 signext %1, float %2) {
%4 = tail call float** @createMatrix(i8 signext %0, i8 signext %1)
%5 = icmp sgt i8 %0, 0
br i1 %5, label %6, label %59
6: ; preds = %3
%7 = icmp sgt i8 %1, 0
%8 = zext i8 %0 to i64
%9 = zext i8 %1 to i64
%10 = add nsw i64 %9, -1
%11 = and i64 %9, 3
%12 = icmp ult i64 %10, 3
%13 = and i64 %9, 252
%14 = icmp eq i64 %11, 0
br label %15
15: ; preds = %6, %56
%16 = phi i64 [ 0, %6 ], [ %57, %56 ]
br i1 %7, label %17, label %56
17: ; preds = %15
%18 = getelementptr inbounds float*, float** %4, i64 %16
br i1 %12, label %43, label %19
19: ; preds = %17
%20 = load float*, float** %18
%21 = load float*, float** %18
br label %22
22: ; preds = %22, %19
%23 = phi i64 [ 0, %19 ], [ %40, %22 ]
%24 = phi i64 [ 0, %19 ], [ %41, %22 ]
%25 = icmp eq i64 %16, %23
%26 = select i1 %25, float %2, float 0.000000e+00
%27 = getelementptr inbounds float, float* %20, i64 %23
store float %26, float* %27
%28 = or i64 %23, 1
%29 = icmp eq i64 %16, %28
%30 = select i1 %29, float %2, float 0.000000e+00
%31 = getelementptr inbounds float, float* %20, i64 %28
store float %30, float* %31
%32 = or i64 %23, 2
%33 = icmp eq i64 %16, %32
%34 = select i1 %33, float %2, float 0.000000e+00
%35 = getelementptr inbounds float, float* %21, i64 %32
store float %34, float* %35
%36 = or i64 %23, 3
%37 = icmp eq i64 %16, %36
%38 = select i1 %37, float %2, float 0.000000e+00
%39 = getelementptr inbounds float, float* %21, i64 %36
store float %38, float* %39
%40 = add nuw nsw i64 %23, 4
%41 = add i64 %24, 4
%42 = icmp eq i64 %41, %13
br i1 %42, label %43, label %22
43: ; preds = %22, %17
%44 = phi i64 [ 0, %17 ], [ %40, %22 ]
br i1 %14, label %56, label %45
45: ; preds = %43
%46 = load float*, float** %18
br label %47
47: ; preds = %47, %45
%48 = phi i64 [ %44, %45 ], [ %53, %47 ]
%49 = phi i64 [ 0, %45 ], [ %54, %47 ]
%50 = icmp eq i64 %16, %48
%51 = select i1 %50, float %2, float 0.000000e+00
%52 = getelementptr inbounds float, float* %46, i64 %48
store float %51, float* %52
%53 = add nuw nsw i64 %48, 1
%54 = add i64 %49, 1
%55 = icmp eq i64 %54, %11
br i1 %55, label %56, label %47
56: ; preds = %43, %47, %15
%57 = add nuw nsw i64 %16, 1
%58 = icmp eq i64 %57, %8
br i1 %58, label %59, label %15
59: ; preds = %56, %3
ret float** %4
}