#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 */
scalar_t__ malloc(size_t);
float ***f3tensor(int nrow, int ncol, int ndep) {
  int i, j;
  float ***t;
  t = (float ***)malloc((size_t)(nrow * sizeof(float **)));
  t[0] = (float **)malloc((size_t)(nrow * ncol * sizeof(float *)));
  t[0][0] = (float *)malloc((size_t)(nrow * ncol * ndep * sizeof(float)));
  for (j = 1; j != ncol; j++)
    t[0][j] = t[0][j - 1] + ndep;
  for (i = 1; i != nrow; i++) {
    t[i] = t[i - 1] + ncol;
    t[i][0] = t[i - 1][0] + ncol * ndep;
    for (j = 1; j != ncol; j++)
      t[i][j] = t[i][j - 1] + ndep;
  }
  return t;
}


x86 assembly (clang, -O0):
<f3tensor>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
movslq -0x4(%rbp),%rdi
shl    $0x3,%rdi
call   1030 <malloc@plt>
mov    %rax,-0x20(%rbp)
mov    -0x4(%rbp),%eax
imul   -0x8(%rbp),%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1030 <malloc@plt>
mov    %rax,%rcx
mov    -0x20(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x4(%rbp),%eax
imul   -0x8(%rbp),%eax
imul   -0xc(%rbp),%eax
movslq %eax,%rdi
shl    $0x2,%rdi
call   1030 <malloc@plt>
mov    %rax,%rcx
mov    -0x20(%rbp),%rax
mov    (%rax),%rax
mov    %rcx,(%rax)
movl   $0x1,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x8(%rbp),%eax
je     11c2 <f3tensor+0xb2>
mov    -0x20(%rbp),%rax
mov    (%rax),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdx
movslq -0xc(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdx
mov    -0x20(%rbp),%rax
mov    (%rax),%rax
movslq -0x14(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    117a <f3tensor+0x6a>
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x4(%rbp),%eax
je     129c <f3tensor+0x18c>
mov    -0x20(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdx
movslq -0x8(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rdx
mov    -0x20(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%rcx
mov    -0x8(%rbp),%eax
imul   -0xc(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rcx
mov    -0x20(%rbp),%rax
movslq -0x10(%rbp),%rdx
mov    (%rax,%rdx,8),%rax
mov    %rcx,(%rax)
movl   $0x1,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x8(%rbp),%eax
je     1289 <f3tensor+0x179>
mov    -0x20(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdx
movslq -0xc(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdx
mov    -0x20(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1237 <f3tensor+0x127>
jmp    128e <f3tensor+0x17e>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    11c9 <f3tensor+0xb9>
mov    -0x20(%rbp),%rax
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<f3tensor>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %edx,%r15d
mov    %esi,%r12d
mov    %edi,%r14d
movslq %edi,%rdi
shl    $0x3,%rdi
call   1030 <malloc@plt>
mov    %rax,%rbx
mov    %r12d,%eax
imul   %r14d,%eax
movslq %eax,%rbp
lea    0x0(,%rbp,8),%rdi
call   1030 <malloc@plt>
mov    %rax,(%rbx)
imul   %r15d,%ebp
movslq %ebp,%rdi
shl    $0x2,%rdi
call   1030 <malloc@plt>
mov    (%rbx),%rcx
mov    %rax,(%rcx)
movslq %r15d,%rax
mov    %r12d,%r8d
cmp    $0x1,%r12d
je     1219 <f3tensor+0x109>
lea    -0x1(%r8),%r9
lea    -0x2(%r8),%rdi
mov    %r9d,%ecx
and    $0x3,%ecx
mov    $0x1,%edx
cmp    $0x3,%rdi
jb     11ed <f3tensor+0xdd>
and    $0xfffffffffffffffc,%r9
xor    %edx,%edx
lea    0x0(,%rax,4),%rdi
nopw   0x0(%rax,%rax,1)
mov    (%rbx),%rbp
mov    0x0(%rbp,%rdx,8),%rsi
add    %rdi,%rsi
mov    %rsi,0x8(%rbp,%rdx,8)
mov    (%rbx),%rsi
mov    0x8(%rsi,%rdx,8),%rbp
add    %rdi,%rbp
mov    %rbp,0x10(%rsi,%rdx,8)
mov    (%rbx),%rsi
mov    0x10(%rsi,%rdx,8),%rbp
add    %rdi,%rbp
mov    %rbp,0x18(%rsi,%rdx,8)
mov    (%rbx),%rsi
mov    0x18(%rsi,%rdx,8),%rbp
add    %rdi,%rbp
mov    %rbp,0x20(%rsi,%rdx,8)
add    $0x4,%rdx
cmp    %rdx,%r9
jne    11a0 <f3tensor+0x90>
add    $0x1,%rdx
test   %rcx,%rcx
je     1219 <f3tensor+0x109>
lea    0x0(,%rax,4),%rsi
nopw   0x0(%rax,%rax,1)
mov    (%rbx),%rdi
mov    -0x8(%rdi,%rdx,8),%rbp
add    %rsi,%rbp
mov    %rbp,(%rdi,%rdx,8)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rcx
jne    1200 <f3tensor+0xf0>
cmp    $0x1,%r14d
jne    1231 <f3tensor+0x121>
mov    %rbx,%rax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
movslq %r12d,%r13
imul   %r12d,%r15d
movslq %r15d,%r11
mov    %r14d,%r10d
lea    -0x1(%r8),%r14
add    $0xfffffffffffffffe,%r8
mov    %r14d,%r9d
and    $0x3,%r9d
and    $0xfffffffffffffffc,%r14
mov    $0x1,%ebp
shl    $0x2,%r11
jmp    1269 <f3tensor+0x159>
nopl   0x0(%rax)
add    $0x1,%rbp
cmp    %r10,%rbp
je     121f <f3tensor+0x10f>
mov    -0x8(%rbx,%rbp,8),%rsi
lea    (%rsi,%r13,8),%rdi
mov    %rdi,(%rbx,%rbp,8)
mov    (%rsi),%rdi
add    %r11,%rdi
mov    %rdi,(%rsi,%r13,8)
cmp    $0x1,%r12d
je     1260 <f3tensor+0x150>
mov    $0x1,%edi
cmp    $0x3,%r8
jb     12f5 <f3tensor+0x1e5>
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%rbx,%rbp,8),%rsi
lea    0x0(,%rax,4),%rdx
mov    (%rsi,%rdi,8),%rcx
add    %rdx,%rcx
mov    %rcx,0x8(%rsi,%rdi,8)
mov    (%rbx,%rbp,8),%rcx
mov    0x8(%rcx,%rdi,8),%rsi
add    %rdx,%rsi
mov    %rsi,0x10(%rcx,%rdi,8)
mov    (%rbx,%rbp,8),%rcx
mov    0x10(%rcx,%rdi,8),%rsi
add    %rdx,%rsi
mov    %rsi,0x18(%rcx,%rdi,8)
mov    (%rbx,%rbp,8),%rcx
add    0x18(%rcx,%rdi,8),%rdx
mov    %rdx,0x20(%rcx,%rdi,8)
add    $0x4,%rdi
cmp    %rdi,%r14
jne    12a0 <f3tensor+0x190>
add    $0x1,%rdi
test   %r9,%r9
je     1260 <f3tensor+0x150>
mov    %r9,%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%rbx,%rbp,8),%rcx
lea    0x0(,%rax,4),%rdx
add    -0x8(%rcx,%rdi,8),%rdx
mov    %rdx,(%rcx,%rdi,8)
add    $0x1,%rdi
add    $0xffffffffffffffff,%rsi
jne    1310 <f3tensor+0x200>
jmp    1260 <f3tensor+0x150>

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

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