#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(double **);
scalar_t__ malloc(unsigned int);
int generate_empty_matrix(double ***mat, unsigned int n, unsigned int m) {
  unsigned int iCnt;
  unsigned int i, j;
  if (mat == NULL)
    return -1;
  *mat = (double **)malloc(n * sizeof(double *));
  if (*mat == NULL)
    return -2;
  **mat = (double *)malloc(n * m * sizeof(double));
  if (**mat == NULL) {
    free(*mat);
    *mat = NULL;
    return -2;
  }
  for (iCnt = 1; iCnt < n; iCnt++) {
    (*mat)[iCnt] = &((*mat)[0][iCnt * m]);
  }
  for (i = 0; i < n; i++)
    for (j = 0; j < m; j++)
      (*mat)[i][j] = 0.0;
  return 0;
}


x86 assembly (clang, -O0):
<generate_empty_matrix>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %edx,-0x18(%rbp)
cmpq   $0x0,-0x10(%rbp)
jne    1149 <generate_empty_matrix+0x29>
movl   $0xffffffff,-0x4(%rbp)
jmp    1280 <generate_empty_matrix+0x160>
mov    -0x14(%rbp),%eax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x10(%rbp),%rax
cmpq   $0x0,(%rax)
jne    117b <generate_empty_matrix+0x5b>
movl   $0xfffffffe,-0x4(%rbp)
jmp    1280 <generate_empty_matrix+0x160>
mov    -0x14(%rbp),%eax
imul   -0x18(%rbp),%eax
mov    %eax,%eax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,%rcx
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rcx,(%rax)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
cmpq   $0x0,(%rax)
jne    11d0 <generate_empty_matrix+0xb0>
mov    -0x10(%rbp),%rax
mov    (%rax),%rdi
call   1030 <free@plt>
mov    -0x10(%rbp),%rax
movq   $0x0,(%rax)
movl   $0xfffffffe,-0x4(%rbp)
jmp    1280 <generate_empty_matrix+0x160>
movl   $0x1,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jae    1219 <generate_empty_matrix+0xf9>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    (%rax),%rdx
mov    -0x1c(%rbp),%eax
imul   -0x18(%rbp),%eax
mov    %eax,%eax
shl    $0x3,%rax
add    %rax,%rdx
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    -0x1c(%rbp),%ecx
mov    %rdx,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11d7 <generate_empty_matrix+0xb7>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x14(%rbp),%eax
jae    1279 <generate_empty_matrix+0x159>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x18(%rbp),%eax
jae    1266 <generate_empty_matrix+0x146>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    -0x20(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x24(%rbp),%ecx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1233 <generate_empty_matrix+0x113>
jmp    126b <generate_empty_matrix+0x14b>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1220 <generate_empty_matrix+0x100>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<generate_empty_matrix>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
test   %rdi,%rdi
je     12d3 <generate_empty_matrix+0x1a3>
mov    %edx,%r14d
mov    %esi,%r12d
mov    %rdi,%r13
lea    0x0(,%r12,8),%ebp
mov    %ebp,%edi
call   1050 <malloc@plt>
mov    %rax,0x0(%r13)
mov    $0xfffffffe,%ecx
test   %rax,%rax
je     12f0 <generate_empty_matrix+0x1c0>
imul   %r14d,%ebp
mov    %ebp,%edi
call   1050 <malloc@plt>
mov    0x0(%r13),%rcx
mov    %rax,(%rcx)
mov    0x0(%r13),%rdi
mov    (%rdi),%rax
test   %rax,%rax
je     12de <generate_empty_matrix+0x1ae>
mov    %r12d,%r11d
mov    %r14d,%r15d
cmp    $0x2,%r12d
jb     127e <generate_empty_matrix+0x14e>
lea    (%rax,%r15,8),%rax
mov    %rax,0x8(%rdi)
je     1283 <generate_empty_matrix+0x153>
lea    -0x2(%r11),%r8
lea    -0x3(%r11),%rdx
mov    %r8d,%r10d
and    $0x3,%r10d
mov    $0x2,%ecx
cmp    $0x3,%rdx
jb     1255 <generate_empty_matrix+0x125>
lea    (%r14,%r14,2),%esi
lea    0x0(,%r14,4),%r9d
lea    (%r14,%r14,4),%ebp
lea    (%r14,%r14,1),%edx
and    $0xfffffffffffffffc,%r8
neg    %r8
mov    $0x2,%ecx
mov    %r9d,%edi
nop
mov    0x0(%r13),%rax
mov    %edx,%ebx
shl    $0x3,%rbx
add    (%rax),%rbx
mov    %rbx,(%rax,%rcx,8)
mov    0x0(%r13),%rax
mov    %esi,%ebx
shl    $0x3,%rbx
add    (%rax),%rbx
mov    %rbx,0x8(%rax,%rcx,8)
mov    0x0(%r13),%rax
mov    %edi,%ebx
shl    $0x3,%rbx
add    (%rax),%rbx
mov    %rbx,0x10(%rax,%rcx,8)
mov    0x0(%r13),%rax
mov    %ebp,%ebx
shl    $0x3,%rbx
add    (%rax),%rbx
mov    %rbx,0x18(%rax,%rcx,8)
add    %r9d,%esi
add    %r9d,%ebp
add    %r9d,%edi
add    %r9d,%edx
lea    (%r8,%rcx,1),%rax
add    $0x4,%rax
add    $0x4,%rcx
cmp    $0x2,%rax
jne    11f0 <generate_empty_matrix+0xc0>
test   %r10,%r10
je     127e <generate_empty_matrix+0x14e>
mov    %r14d,%edx
imul   %ecx,%edx
mov    0x0(%r13),%rsi
mov    %edx,%edi
shl    $0x3,%rdi
add    (%rsi),%rdi
mov    %rdi,(%rsi,%rcx,8)
add    $0x1,%rcx
add    %r14d,%edx
add    $0xffffffffffffffff,%r10
jne    1260 <generate_empty_matrix+0x130>
test   %r12d,%r12d
je     12da <generate_empty_matrix+0x1aa>
shl    $0x3,%r15
lea    -0x1(%r11),%rax
mov    %r11d,%ebp
and    $0x3,%ebp
cmp    $0x3,%rax
jae    1301 <generate_empty_matrix+0x1d1>
xor    %r12d,%r12d
test   %rbp,%rbp
mov    $0x0,%ecx
jne    12ba <generate_empty_matrix+0x18a>
jmp    12f0 <generate_empty_matrix+0x1c0>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r12
add    $0xffffffffffffffff,%rbp
je     12da <generate_empty_matrix+0x1aa>
test   %r14d,%r14d
je     12b0 <generate_empty_matrix+0x180>
mov    0x0(%r13),%rax
mov    (%rax,%r12,8),%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1040 <memset@plt>
jmp    12b0 <generate_empty_matrix+0x180>
mov    $0xffffffff,%ecx
jmp    12f0 <generate_empty_matrix+0x1c0>
xor    %ecx,%ecx
jmp    12f0 <generate_empty_matrix+0x1c0>
call   1030 <free@plt>
movq   $0x0,0x0(%r13)
mov    $0xfffffffe,%ecx
mov    %ecx,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
and    $0xfffffffc,%r11d
xor    %r12d,%r12d
jmp    1319 <generate_empty_matrix+0x1e9>
nopw   0x0(%rax,%rax,1)
add    $0x4,%r12
cmp    %r12,%r11
je     129a <generate_empty_matrix+0x16a>
test   %r14d,%r14d
je     1310 <generate_empty_matrix+0x1e0>
mov    0x0(%r13),%rax
mov    (%rax,%r12,8),%rdi
xor    %esi,%esi
mov    %r15,%rdx
mov    %r11,%rbx
call   1040 <memset@plt>
mov    0x0(%r13),%rax
mov    0x8(%rax,%r12,8),%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1040 <memset@plt>
mov    0x0(%r13),%rax
mov    0x10(%rax,%r12,8),%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1040 <memset@plt>
mov    0x0(%r13),%rax
mov    0x18(%rax,%r12,8),%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1040 <memset@plt>
mov    %rbx,%r11
jmp    1310 <generate_empty_matrix+0x1e0>

LLVM IR (-O0):
define i32 @generate_empty_matrix(double*** %0, i32 %1, i32 %2) {
%4 = alloca i32
%5 = alloca double***
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
store double*** %0, double**** %5
store i32 %1, i32* %6
store i32 %2, i32* %7
%11 = load double***, double**** %5
%12 = icmp eq double*** %11, null
br i1 %12, label %13, label %14
13: ; preds = %3
store i32 -1, i32* %4
br label %97
14: ; preds = %3
%15 = load i32, i32* %6
%16 = zext i32 %15 to i64
%17 = mul i64 %16, 8
%18 = trunc i64 %17 to i32
%19 = call i64 @malloc(i32 %18)
%20 = inttoptr i64 %19 to double**
%21 = load double***, double**** %5
store double** %20, double*** %21
%22 = load double***, double**** %5
%23 = load double**, double*** %22
%24 = icmp eq double** %23, null
br i1 %24, label %25, label %26
25: ; preds = %14
store i32 -2, i32* %4
br label %97
26: ; preds = %14
%27 = load i32, i32* %6
%28 = load i32, i32* %7
%29 = mul i32 %27, %28
%30 = zext i32 %29 to i64
%31 = mul i64 %30, 8
%32 = trunc i64 %31 to i32
%33 = call i64 @malloc(i32 %32)
%34 = inttoptr i64 %33 to double*
%35 = load double***, double**** %5
%36 = load double**, double*** %35
store double* %34, double** %36
%37 = load double***, double**** %5
%38 = load double**, double*** %37
%39 = load double*, double** %38
%40 = icmp eq double* %39, null
br i1 %40, label %41, label %46
41: ; preds = %26
%42 = load double***, double**** %5
%43 = load double**, double*** %42
%44 = call i32 @free(double** %43)
%45 = load double***, double**** %5
store double** null, double*** %45
store i32 -2, i32* %4
br label %97
46: ; preds = %26
store i32 1, i32* %8
br label %47
47: ; preds = %66, %46
%48 = load i32, i32* %8
%49 = load i32, i32* %6
%50 = icmp ult i32 %48, %49
br i1 %50, label %51, label %69
51: ; preds = %47
%52 = load double***, double**** %5
%53 = load double**, double*** %52
%54 = getelementptr inbounds double*, double** %53, i64 0
%55 = load double*, double** %54
%56 = load i32, i32* %8
%57 = load i32, i32* %7
%58 = mul i32 %56, %57
%59 = zext i32 %58 to i64
%60 = getelementptr inbounds double, double* %55, i64 %59
%61 = load double***, double**** %5
%62 = load double**, double*** %61
%63 = load i32, i32* %8
%64 = zext i32 %63 to i64
%65 = getelementptr inbounds double*, double** %62, i64 %64
store double* %60, double** %65
br label %66
66: ; preds = %51
%67 = load i32, i32* %8
%68 = add i32 %67, 1
store i32 %68, i32* %8
br label %47
69: ; preds = %47
store i32 0, i32* %9
br label %70
70: ; preds = %93, %69
%71 = load i32, i32* %9
%72 = load i32, i32* %6
%73 = icmp ult i32 %71, %72
br i1 %73, label %74, label %96
74: ; preds = %70
store i32 0, i32* %10
br label %75
75: ; preds = %89, %74
%76 = load i32, i32* %10
%77 = load i32, i32* %7
%78 = icmp ult i32 %76, %77
br i1 %78, label %79, label %92
79: ; preds = %75
%80 = load double***, double**** %5
%81 = load double**, double*** %80
%82 = load i32, i32* %9
%83 = zext i32 %82 to i64
%84 = getelementptr inbounds double*, double** %81, i64 %83
%85 = load double*, double** %84
%86 = load i32, i32* %10
%87 = zext i32 %86 to i64
%88 = getelementptr inbounds double, double* %85, i64 %87
store double 0.000000e+00, double* %88
br label %89
89: ; preds = %79
%90 = load i32, i32* %10
%91 = add i32 %90, 1
store i32 %91, i32* %10
br label %75
92: ; preds = %75
br label %93
93: ; preds = %92
%94 = load i32, i32* %9
%95 = add i32 %94, 1
store i32 %95, i32* %9
br label %70
96: ; preds = %70
store i32 0, i32* %4
br label %97
97: ; preds = %96, %41, %25, %13
%98 = load i32, i32* %4
ret i32 %98
}

LLVM IR (-O2):
define i32 @generate_empty_matrix(double*** %0, i32 %1, i32 %2) {
%4 = icmp eq double*** %0, null
br i1 %4, label %142, label %5
5: ; preds = %3
%6 = shl i32 %1, 3
%7 = tail call i64 @malloc(i32 %6)
%8 = inttoptr i64 %7 to double**
store double** %8, double*** %0
%9 = icmp eq i64 %7, 0
br i1 %9, label %142, label %10
10: ; preds = %5
%11 = mul i32 %6, %2
%12 = tail call i64 @malloc(i32 %11)
%13 = inttoptr i64 %12 to double*
%14 = load double**, double*** %0
store double* %13, double** %14
%15 = load double**, double*** %0
%16 = load double*, double** %15
%17 = icmp eq double* %16, null
br i1 %17, label %33, label %18
18: ; preds = %10
%19 = icmp ugt i32 %1, 1
br i1 %19, label %20, label %51
20: ; preds = %18
%21 = zext i32 %1 to i64
%22 = zext i32 %2 to i64
%23 = getelementptr inbounds double, double* %16, i64 %22
%24 = getelementptr inbounds double*, double** %15, i64 1
store double* %23, double** %24
%25 = icmp eq i32 %1, 2
br i1 %25, label %53, label %26
26: ; preds = %20
%27 = add nsw i64 %21, -2
%28 = add nsw i64 %21, -3
%29 = and i64 %27, 3
%30 = icmp ult i64 %28, 3
br i1 %30, label %35, label %31
31: ; preds = %26
%32 = and i64 %27, -4
br label %63
33: ; preds = %10
%34 = tail call i32 @free(double** %15)
store double** null, double*** %0
br label %142
35: ; preds = %63, %26
%36 = phi i64 [ 2, %26 ], [ %97, %63 ]
%37 = icmp eq i64 %29, 0
br i1 %37, label %51, label %38
38: ; preds = %35, %38
%39 = phi i64 [ %48, %38 ], [ %36, %35 ]
%40 = phi i64 [ %49, %38 ], [ 0, %35 ]
%41 = load double**, double*** %0
%42 = load double*, double** %41
%43 = trunc i64 %39 to i32
%44 = mul i32 %43, %2
%45 = zext i32 %44 to i64
%46 = getelementptr inbounds double, double* %42, i64 %45
%47 = getelementptr inbounds double*, double** %41, i64 %39
store double* %46, double** %47
%48 = add nuw nsw i64 %39, 1
%49 = add i64 %40, 1
%50 = icmp eq i64 %49, %29
br i1 %50, label %51, label %38
51: ; preds = %35, %38, %18
%52 = icmp eq i32 %1, 0
br i1 %52, label %142, label %53
53: ; preds = %20, %51
%54 = icmp eq i32 %2, 0
%55 = zext i32 %2 to i64
%56 = shl nuw nsw i64 %55, 3
%57 = zext i32 %1 to i64
%58 = add nsw i64 %57, -1
%59 = and i64 %57, 3
%60 = icmp ult i64 %58, 3
br i1 %60, label %127, label %61
61: ; preds = %53
%62 = and i64 %57, 4294967292
br label %100
63: ; preds = %63, %31
%64 = phi i64 [ 2, %31 ], [ %97, %63 ]
%65 = phi i64 [ 0, %31 ], [ %98, %63 ]
%66 = load double**, double*** %0
%67 = load double*, double** %66
%68 = trunc i64 %64 to i32
%69 = mul i32 %68, %2
%70 = zext i32 %69 to i64
%71 = getelementptr inbounds double, double* %67, i64 %70
%72 = getelementptr inbounds double*, double** %66, i64 %64
store double* %71, double** %72
%73 = or i64 %64, 1
%74 = load double**, double*** %0
%75 = load double*, double** %74
%76 = trunc i64 %73 to i32
%77 = mul i32 %76, %2
%78 = zext i32 %77 to i64
%79 = getelementptr inbounds double, double* %75, i64 %78
%80 = getelementptr inbounds double*, double** %74, i64 %73
store double* %79, double** %80
%81 = add nuw nsw i64 %64, 2
%82 = load double**, double*** %0
%83 = load double*, double** %82
%84 = trunc i64 %81 to i32
%85 = mul i32 %84, %2
%86 = zext i32 %85 to i64
%87 = getelementptr inbounds double, double* %83, i64 %86
%88 = getelementptr inbounds double*, double** %82, i64 %81
store double* %87, double** %88
%89 = add nuw nsw i64 %64, 3
%90 = load double**, double*** %0
%91 = load double*, double** %90
%92 = trunc i64 %89 to i32
%93 = mul i32 %92, %2
%94 = zext i32 %93 to i64
%95 = getelementptr inbounds double, double* %91, i64 %94
%96 = getelementptr inbounds double*, double** %90, i64 %89
store double* %95, double** %96
%97 = add nuw nsw i64 %64, 4
%98 = add i64 %65, 4
%99 = icmp eq i64 %98, %32
br i1 %99, label %35, label %63
100: ; preds = %123, %61
%101 = phi i64 [ 0, %61 ], [ %124, %123 ]
%102 = phi i64 [ 0, %61 ], [ %125, %123 ]
br i1 %54, label %123, label %103
103: ; preds = %100
%104 = load double**, double*** %0
%105 = getelementptr inbounds double*, double** %104, i64 %101
%106 = bitcast double** %105 to i8**
%107 = load i8*, i8** %106
%108 = or i64 %101, 1
%109 = load double**, double*** %0
%110 = getelementptr inbounds double*, double** %109, i64 %108
%111 = bitcast double** %110 to i8**
%112 = load i8*, i8** %111
%113 = or i64 %101, 2
%114 = load double**, double*** %0
%115 = getelementptr inbounds double*, double** %114, i64 %113
%116 = bitcast double** %115 to i8**
%117 = load i8*, i8** %116
%118 = or i64 %101, 3
%119 = load double**, double*** %0
%120 = getelementptr inbounds double*, double** %119, i64 %118
%121 = bitcast double** %120 to i8**
%122 = load i8*, i8** %121
br label %123
123: ; preds = %100, %103
%124 = add nuw nsw i64 %101, 4
%125 = add i64 %102, 4
%126 = icmp eq i64 %125, %62
br i1 %126, label %127, label %100
127: ; preds = %123, %53
%128 = phi i64 [ 0, %53 ], [ %124, %123 ]
%129 = icmp eq i64 %59, 0
br i1 %129, label %142, label %130
130: ; preds = %127, %138
%131 = phi i64 [ %139, %138 ], [ %128, %127 ]
%132 = phi i64 [ %140, %138 ], [ 0, %127 ]
br i1 %54, label %138, label %133
133: ; preds = %130
%134 = load double**, double*** %0
%135 = getelementptr inbounds double*, double** %134, i64 %131
%136 = bitcast double** %135 to i8**
%137 = load i8*, i8** %136
br label %138
138: ; preds = %133, %130
%139 = add nuw nsw i64 %131, 1
%140 = add i64 %132, 1
%141 = icmp eq i64 %140, %59
br i1 %141, label %142, label %130
142: ; preds = %127, %138, %51, %5, %3, %33
%143 = phi i32 [ -2, %33 ], [ -1, %3 ], [ -2, %5 ], [ 0, %51 ], [ 0, %138 ], [ 0, %127 ]
ret i32 %143
}