int main() {
  int a[2];
  int *b[2];
  int(*c)[2];
  int *d[2][3];
  int(*e[2])[3];
  int *(*f[2])[3];
  int ***g1[2][3][4];
  int ***((((g2)[2])[3])[4]);
  int(*(*(*((((g3)[2])[3])[4]))));
  int **(*h)[2][3][4];
  int *(**i[2][3])[4];
  int(*(*(*j)[2])[3])[4];
  char aa = a;
  char bb = b;
  char cc = c;
  char dd = d;
  char ee = e;
  char ff = f;
  char gg1 = g1;
  char gg2 = g2;
  char gg3 = g3;
  char hh = h;
  char ii = i;
  char jj = j;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x2a0,%rsp
lea    -0x8(%rbp),%rax
mov    %al,-0x309(%rbp)
lea    -0x20(%rbp),%rax
mov    %al,-0x30a(%rbp)
mov    -0x28(%rbp),%rax
mov    %al,-0x30b(%rbp)
lea    -0x60(%rbp),%rax
mov    %al,-0x30c(%rbp)
lea    -0x70(%rbp),%rax
mov    %al,-0x30d(%rbp)
lea    -0x80(%rbp),%rax
mov    %al,-0x30e(%rbp)
lea    -0x140(%rbp),%rax
mov    %al,-0x30f(%rbp)
lea    -0x200(%rbp),%rax
mov    %al,-0x310(%rbp)
lea    -0x2c0(%rbp),%rax
mov    %al,-0x311(%rbp)
mov    -0x2c8(%rbp),%rax
mov    %al,-0x312(%rbp)
lea    -0x300(%rbp),%rax
mov    %al,-0x313(%rbp)
mov    -0x308(%rbp),%rax
mov    %al,-0x314(%rbp)
xor    %eax,%eax
add    $0x2a0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
xor    %eax,%eax
ret

LLVM IR (-O0):
define i32 @main() {
%1 = alloca [2 x i32]
%2 = alloca [2 x i32*]
%3 = alloca [2 x i32]*
%4 = alloca [2 x [3 x i32*]]
%5 = alloca [2 x [3 x i32]*]
%6 = alloca [2 x [3 x i32*]*]
%7 = alloca [2 x [3 x [4 x i32***]]]
%8 = alloca [2 x [3 x [4 x i32***]]]
%9 = alloca [2 x [3 x [4 x i32***]]]
%10 = alloca [2 x [3 x [4 x i32**]]]*
%11 = alloca [2 x [3 x [4 x i32*]**]]
%12 = alloca [2 x [3 x [4 x i32]*]*]*
%13 = alloca i8
%14 = alloca i8
%15 = alloca i8
%16 = alloca i8
%17 = alloca i8
%18 = alloca i8
%19 = alloca i8
%20 = alloca i8
%21 = alloca i8
%22 = alloca i8
%23 = alloca i8
%24 = alloca i8
%25 = getelementptr inbounds [2 x i32], [2 x i32]* %1, i64 0, i64 0
%26 = ptrtoint i32* %25 to i8
store i8 %26, i8* %13
%27 = getelementptr inbounds [2 x i32*], [2 x i32*]* %2, i64 0, i64 0
%28 = ptrtoint i32** %27 to i8
store i8 %28, i8* %14
%29 = load [2 x i32]*, [2 x i32]** %3
%30 = ptrtoint [2 x i32]* %29 to i8
store i8 %30, i8* %15
%31 = getelementptr inbounds [2 x [3 x i32*]], [2 x [3 x i32*]]* %4, i64 0, i64 0
%32 = ptrtoint [3 x i32*]* %31 to i8
store i8 %32, i8* %16
%33 = getelementptr inbounds [2 x [3 x i32]*], [2 x [3 x i32]*]* %5, i64 0, i64 0
%34 = ptrtoint [3 x i32]** %33 to i8
store i8 %34, i8* %17
%35 = getelementptr inbounds [2 x [3 x i32*]*], [2 x [3 x i32*]*]* %6, i64 0, i64 0
%36 = ptrtoint [3 x i32*]** %35 to i8
store i8 %36, i8* %18
%37 = getelementptr inbounds [2 x [3 x [4 x i32***]]], [2 x [3 x [4 x i32***]]]* %7, i64 0, i64 0
%38 = ptrtoint [3 x [4 x i32***]]* %37 to i8
store i8 %38, i8* %19
%39 = getelementptr inbounds [2 x [3 x [4 x i32***]]], [2 x [3 x [4 x i32***]]]* %8, i64 0, i64 0
%40 = ptrtoint [3 x [4 x i32***]]* %39 to i8
store i8 %40, i8* %20
%41 = getelementptr inbounds [2 x [3 x [4 x i32***]]], [2 x [3 x [4 x i32***]]]* %9, i64 0, i64 0
%42 = ptrtoint [3 x [4 x i32***]]* %41 to i8
store i8 %42, i8* %21
%43 = load [2 x [3 x [4 x i32**]]]*, [2 x [3 x [4 x i32**]]]** %10
%44 = ptrtoint [2 x [3 x [4 x i32**]]]* %43 to i8
store i8 %44, i8* %22
%45 = getelementptr inbounds [2 x [3 x [4 x i32*]**]], [2 x [3 x [4 x i32*]**]]* %11, i64 0, i64 0
%46 = ptrtoint [3 x [4 x i32*]**]* %45 to i8
store i8 %46, i8* %23
%47 = load [2 x [3 x [4 x i32]*]*]*, [2 x [3 x [4 x i32]*]*]** %12
%48 = ptrtoint [2 x [3 x [4 x i32]*]*]* %47 to i8
store i8 %48, i8* %24
ret i32 0
}

LLVM IR (-O2):
define i32 @main() {
ret i32 0
}