int main() {
  struct node {
    int hash;
    int value;
  };
  struct root {
    int fake;
    int fake2;
    struct node nodes[0];
  };
  struct root_s {
    int fake;
    int fake2;
    struct node *nodes;
  };
  struct root *hroot;
  struct root_s *sroot;
  printf("sizeof root: %d\n", sizeof(struct root));
  printf("\nsizeof hroot: %d\n", sizeof(hroot));
  hroot = (struct root *)malloc(sizeof(struct root) + 20 * sizeof(struct node));
  printf("sizeof hroot: %d\n", sizeof(hroot));
  printf("sizeof *hroot: %d\n", sizeof(*hroot));
  printf("sizeof hroot->nodes: %d\n", sizeof(hroot->nodes));
  printf("sizeof hroot->nodes[0]: %d\n", sizeof(hroot->nodes[0]));
  printf("sizeof hroot->nodes[19]: %d\n", sizeof(hroot->nodes[19]));
  printf("sizeof hroot->nodes[21]: %d\n", sizeof(hroot->nodes[21]));
  printf("sizeof hroot->nodes[100]: %d\n", sizeof(hroot->nodes[100]));
  hroot->nodes[0].hash = 0;
  hroot->nodes[19].hash = 1;
  hroot->nodes[21].hash = 2;
  hroot->nodes[100].hash = 3;
  printf("sizeof hroot->nodes[0]: %d\n", sizeof(hroot->nodes[0]));
  printf("sizeof hroot->nodes[19]: %d\n", sizeof(hroot->nodes[19]));
  printf("sizeof hroot->nodes[21]: %d\n", sizeof(hroot->nodes[21]));
  printf("sizeof hroot->nodes[100]: %d\n", sizeof(hroot->nodes[100]));
  printf("hroot->nodes[0].hash: %d\n", hroot->nodes[0].hash);
  printf("hroot->nodes[19].hash: %d\n", hroot->nodes[19].hash);
  printf("hroot->nodes[21].hash: %d\n", hroot->nodes[21].hash);
  printf("hroot->nodes[100].hash: %d\n", hroot->nodes[100].hash);
  free(hroot);
  printf("\nsizeof sroot: %d\n", sizeof(sroot));
  sroot = (struct root_s *)malloc(sizeof(struct root_s));
  sroot->nodes = (struct node *)malloc(20 * sizeof(struct node));
  printf("sizeof sroot: %d\n", sizeof(sroot));
  printf("sizeof *sroot: %d\n", sizeof(*sroot));
  printf("sizeof sroot->nodes: %d\n", sizeof(sroot->nodes));
  printf("sizeof sroot->nodes[0]: %d\n", sizeof(sroot->nodes[0]));
  printf("sizeof sroot->nodes[19]: %d\n", sizeof(sroot->nodes[19]));
  printf("sizeof sroot->nodes[21]: %d\n", sizeof(sroot->nodes[21]));
  printf("sizeof sroot->nodes[100]: %d\n", sizeof(sroot->nodes[100]));
  sroot->nodes[0].hash = 0;
  sroot->nodes[19].hash = 1;
  printf("sizeof sroot->nodes[0]: %d\n", sizeof(sroot->nodes[0]));
  printf("sizeof sroot->nodes[19]: %d\n", sizeof(sroot->nodes[19]));
  printf("sizeof sroot->nodes[21]: %d\n", sizeof(sroot->nodes[21]));
  printf("sizeof sroot->nodes[100]: %d\n", sizeof(sroot->nodes[100]));
  printf("sroot->nodes[0].hash: %d\n", sroot->nodes[0].hash);
  printf("sroot->nodes[19].hash: %d\n", sroot->nodes[19].hash);
  printf("sroot->nodes[21].hash: %d\n", sroot->nodes[21].hash);
  printf("sroot->nodes[100].hash: %d\n", sroot->nodes[100].hash);
  free(sroot->nodes);
  free(sroot);
  struct root_v {
    int fake;
    int fake2;
    struct node nodes[5];
  };
  struct root_v vroot = {
      .fake = 1,
      .fake2 = 2,
      .nodes[0] =
          {
              .hash = 3,
              .value = 4,
          },
  };
  printf("\nsizeof rootv: %d\n", sizeof(struct root_v));
  printf("sizeof vroot: %d\n", sizeof(vroot));
  printf("vroot->nodes[0].hash: %d\n", vroot.nodes[0].hash);
  printf("vroot->nodes[1].hash: %d\n", vroot.nodes[1].hash);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
movl   $0x0,-0x4(%rbp)
lea    0xeaa(%rip),%rdi
mov    $0x8,%esi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xea8(%rip),%rdi
mov    $0x8,%esi
mov    $0x0,%al
call   1040 <printf@plt>
mov    $0xa8,%edi
call   1060 <malloc@plt>
mov    %rax,-0x10(%rbp)
lea    0xe88(%rip),%rdi
mov    $0x8,%esi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xe87(%rip),%rdi
mov    $0x8,%esi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xe87(%rip),%rdi
xor    %eax,%eax
mov    %eax,%esi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xe8e(%rip),%rdi
mov    $0x8,%esi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xe97(%rip),%rdi
mov    $0x8,%esi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xea1(%rip),%rdi
mov    $0x8,%esi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xeab(%rip),%rdi
mov    $0x8,%esi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x10(%rbp),%rax
movl   $0x0,0x8(%rax)
mov    -0x10(%rbp),%rax
movl   $0x1,0xa0(%rax)
mov    -0x10(%rbp),%rax
movl   $0x2,0xb0(%rax)
mov    -0x10(%rbp),%rax
movl   $0x3,0x328(%rax)
lea    0xe0d(%rip),%rdi
mov    $0x8,%esi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xe16(%rip),%rdi
mov    $0x8,%esi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xe20(%rip),%rdi
mov    $0x8,%esi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xe2a(%rip),%rdi
mov    $0x8,%esi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%esi
lea    0xe2e(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x10(%rbp),%rax
mov    0xa0(%rax),%esi
lea    0xe30(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x10(%rbp),%rax
mov    0xb0(%rax),%esi
lea    0xe33(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x10(%rbp),%rax
mov    0x328(%rax),%esi
lea    0xe36(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x10(%rbp),%rdi
call   1030 <free@plt>
lea    0xe3b(%rip),%rdi
mov    $0x8,%esi
mov    $0x0,%al
call   1040 <printf@plt>
mov    $0x10,%edi
call   1060 <malloc@plt>
mov    %rax,-0x18(%rbp)
mov    $0xa0,%edi
call   1060 <malloc@plt>
mov    %rax,%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,0x8(%rax)
lea    0xe06(%rip),%rdi
mov    $0x8,%esi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xe05(%rip),%rdi
mov    $0x10,%esi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xe05(%rip),%rdi
mov    $0x8,%esi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xe0b(%rip),%rdi
mov    $0x8,%esi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xe14(%rip),%rdi
mov    $0x8,%esi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xe1e(%rip),%rdi
mov    $0x8,%esi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xe28(%rip),%rdi
mov    $0x8,%esi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x18(%rbp),%rax
mov    0x8(%rax),%rax
movl   $0x0,(%rax)
mov    -0x18(%rbp),%rax
mov    0x8(%rax),%rax
movl   $0x1,0x98(%rax)
lea    0xd9f(%rip),%rdi
mov    $0x8,%esi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xda8(%rip),%rdi
mov    $0x8,%esi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xdb2(%rip),%rdi
mov    $0x8,%esi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xdbc(%rip),%rdi
mov    $0x8,%esi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x18(%rbp),%rax
mov    0x8(%rax),%rax
mov    (%rax),%esi
lea    0xdbd(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x18(%rbp),%rax
mov    0x8(%rax),%rax
mov    0x98(%rax),%esi
lea    0xdbb(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x18(%rbp),%rax
mov    0x8(%rax),%rax
mov    0xa8(%rax),%esi
lea    0xdba(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x18(%rbp),%rax
mov    0x8(%rax),%rax
mov    0x320(%rax),%esi
lea    0xdb9(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x18(%rbp),%rax
mov    0x8(%rax),%rdi
call   1030 <free@plt>
mov    -0x18(%rbp),%rdi
call   1030 <free@plt>
lea    -0x48(%rbp),%rdi
xor    %esi,%esi
mov    $0x30,%edx
call   1050 <memset@plt>
movl   $0x1,-0x48(%rbp)
movl   $0x2,-0x44(%rbp)
movl   $0x3,-0x40(%rbp)
movl   $0x4,-0x3c(%rbp)
lea    0xd85(%rip),%rdi
mov    $0x30,%esi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xd85(%rip),%rdi
mov    $0x30,%esi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x40(%rbp),%esi
lea    0xd81(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x38(%rbp),%esi
lea    0xd8a(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
xor    %eax,%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
lea    0xec0(%rip),%rdi
mov    $0x8,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xebe(%rip),%rdi
mov    $0x8,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xeac(%rip),%rdi
mov    $0x8,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xeab(%rip),%rdi
mov    $0x8,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xeab(%rip),%rdi
xor    %esi,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xeb4(%rip),%r14
mov    $0x8,%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xeba(%rip),%r15
mov    $0x8,%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xec1(%rip),%r12
mov    $0x8,%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xec8(%rip),%rbx
mov    $0x8,%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0x8,%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0x8,%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0x8,%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0x8,%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xe94(%rip),%rdi
xor    %esi,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xe9e(%rip),%rdi
mov    $0x1,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xea6(%rip),%rdi
mov    $0x2,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xeae(%rip),%rdi
mov    $0x3,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xeb7(%rip),%rdi
mov    $0x8,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xa0,%edi
call   1050 <malloc@plt>
mov    %rax,%rbx
lea    0xe98(%rip),%rdi
mov    $0x8,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xe97(%rip),%rdi
mov    $0x10,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xe97(%rip),%rdi
mov    $0x8,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xe9d(%rip),%r14
mov    $0x8,%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xea3(%rip),%r15
mov    $0x8,%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xeaa(%rip),%r12
mov    $0x8,%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xeb1(%rip),%r13
mov    $0x8,%esi
mov    %r13,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movl   $0x0,(%rbx)
movl   $0x1,0x98(%rbx)
mov    $0x8,%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0x8,%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0x8,%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0x8,%esi
mov    %r13,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    (%rbx),%esi
lea    0xe6b(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x98(%rbx),%esi
lea    0xe71(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0xa8(%rbx),%esi
lea    0xe78(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x320(%rbx),%esi
lea    0xe7f(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
lea    0xe85(%rip),%rdi
mov    $0x30,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xe85(%rip),%rdi
mov    $0x30,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xe84(%rip),%rdi
mov    $0x3,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xe8b(%rip),%rdi
xor    %esi,%esi
xor    %eax,%eax
call   1040 <printf@plt>
xor    %eax,%eax
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
%struct.root = type { i32, i32, [0 x %struct.node] }
%struct.node = type { i32, i32 }
%struct.root_s = type { i32, i32, %struct.node* }
%struct.root_v = type { i32, i32, [5 x %struct.node] }
@.str = [17 x i8] c"sizeof root: %d\0A\00"
@.str.1 = [19 x i8] c"\0Asizeof hroot: %d\0A\00"
@.str.2 = [18 x i8] c"sizeof hroot: %d\0A\00"
@.str.3 = [19 x i8] c"sizeof *hroot: %d\0A\00"
@.str.4 = [25 x i8] c"sizeof hroot->nodes: %d\0A\00"
@.str.5 = [28 x i8] c"sizeof hroot->nodes[0]: %d\0A\00"
@.str.6 = [29 x i8] c"sizeof hroot->nodes[19]: %d\0A\00"
@.str.7 = [29 x i8] c"sizeof hroot->nodes[21]: %d\0A\00"
@.str.8 = [30 x i8] c"sizeof hroot->nodes[100]: %d\0A\00"
@.str.9 = [26 x i8] c"hroot->nodes[0].hash: %d\0A\00"
@.str.10 = [27 x i8] c"hroot->nodes[19].hash: %d\0A\00"
@.str.11 = [27 x i8] c"hroot->nodes[21].hash: %d\0A\00"
@.str.12 = [28 x i8] c"hroot->nodes[100].hash: %d\0A\00"
@.str.13 = [19 x i8] c"\0Asizeof sroot: %d\0A\00"
@.str.14 = [18 x i8] c"sizeof sroot: %d\0A\00"
@.str.15 = [19 x i8] c"sizeof *sroot: %d\0A\00"
@.str.16 = [25 x i8] c"sizeof sroot->nodes: %d\0A\00"
@.str.17 = [28 x i8] c"sizeof sroot->nodes[0]: %d\0A\00"
@.str.18 = [29 x i8] c"sizeof sroot->nodes[19]: %d\0A\00"
@.str.19 = [29 x i8] c"sizeof sroot->nodes[21]: %d\0A\00"
@.str.20 = [30 x i8] c"sizeof sroot->nodes[100]: %d\0A\00"
@.str.21 = [26 x i8] c"sroot->nodes[0].hash: %d\0A\00"
@.str.22 = [27 x i8] c"sroot->nodes[19].hash: %d\0A\00"
@.str.23 = [27 x i8] c"sroot->nodes[21].hash: %d\0A\00"
@.str.24 = [28 x i8] c"sroot->nodes[100].hash: %d\0A\00"
@.str.25 = [19 x i8] c"\0Asizeof rootv: %d\0A\00"
@.str.26 = [18 x i8] c"sizeof vroot: %d\0A\00"
@.str.27 = [26 x i8] c"vroot->nodes[0].hash: %d\0A\00"
@.str.28 = [26 x i8] c"vroot->nodes[1].hash: %d\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca %struct.root*
%3 = alloca %struct.root_s*
%4 = alloca %struct.root_v
store i32 0, i32* %1
%5 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str, i64 0, i64 0), i64 8)
%6 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.1, i64 0, i64 0), i64 8)
%7 = call i8* @malloc(i64 168)
%8 = bitcast i8* %7 to %struct.root*
store %struct.root* %8, %struct.root** %2
%9 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.2, i64 0, i64 0), i64 8)
%10 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.3, i64 0, i64 0), i64 8)
%11 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.4, i64 0, i64 0), i64 0)
%12 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.5, i64 0, i64 0), i64 8)
%13 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.6, i64 0, i64 0), i64 8)
%14 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.7, i64 0, i64 0), i64 8)
%15 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.8, i64 0, i64 0), i64 8)
%16 = load %struct.root*, %struct.root** %2
%17 = getelementptr inbounds %struct.root, %struct.root* %16, i32 0, i32 2
%18 = getelementptr inbounds [0 x %struct.node], [0 x %struct.node]* %17, i64 0, i64 0
%19 = getelementptr inbounds %struct.node, %struct.node* %18, i32 0, i32 0
store i32 0, i32* %19
%20 = load %struct.root*, %struct.root** %2
%21 = getelementptr inbounds %struct.root, %struct.root* %20, i32 0, i32 2
%22 = getelementptr inbounds [0 x %struct.node], [0 x %struct.node]* %21, i64 0, i64 19
%23 = getelementptr inbounds %struct.node, %struct.node* %22, i32 0, i32 0
store i32 1, i32* %23
%24 = load %struct.root*, %struct.root** %2
%25 = getelementptr inbounds %struct.root, %struct.root* %24, i32 0, i32 2
%26 = getelementptr inbounds [0 x %struct.node], [0 x %struct.node]* %25, i64 0, i64 21
%27 = getelementptr inbounds %struct.node, %struct.node* %26, i32 0, i32 0
store i32 2, i32* %27
%28 = load %struct.root*, %struct.root** %2
%29 = getelementptr inbounds %struct.root, %struct.root* %28, i32 0, i32 2
%30 = getelementptr inbounds [0 x %struct.node], [0 x %struct.node]* %29, i64 0, i64 100
%31 = getelementptr inbounds %struct.node, %struct.node* %30, i32 0, i32 0
store i32 3, i32* %31
%32 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.5, i64 0, i64 0), i64 8)
%33 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.6, i64 0, i64 0), i64 8)
%34 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.7, i64 0, i64 0), i64 8)
%35 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.8, i64 0, i64 0), i64 8)
%36 = load %struct.root*, %struct.root** %2
%37 = getelementptr inbounds %struct.root, %struct.root* %36, i32 0, i32 2
%38 = getelementptr inbounds [0 x %struct.node], [0 x %struct.node]* %37, i64 0, i64 0
%39 = getelementptr inbounds %struct.node, %struct.node* %38, i32 0, i32 0
%40 = load i32, i32* %39
%41 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.9, i64 0, i64 0), i32 %40)
%42 = load %struct.root*, %struct.root** %2
%43 = getelementptr inbounds %struct.root, %struct.root* %42, i32 0, i32 2
%44 = getelementptr inbounds [0 x %struct.node], [0 x %struct.node]* %43, i64 0, i64 19
%45 = getelementptr inbounds %struct.node, %struct.node* %44, i32 0, i32 0
%46 = load i32, i32* %45
%47 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.10, i64 0, i64 0), i32 %46)
%48 = load %struct.root*, %struct.root** %2
%49 = getelementptr inbounds %struct.root, %struct.root* %48, i32 0, i32 2
%50 = getelementptr inbounds [0 x %struct.node], [0 x %struct.node]* %49, i64 0, i64 21
%51 = getelementptr inbounds %struct.node, %struct.node* %50, i32 0, i32 0
%52 = load i32, i32* %51
%53 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.11, i64 0, i64 0), i32 %52)
%54 = load %struct.root*, %struct.root** %2
%55 = getelementptr inbounds %struct.root, %struct.root* %54, i32 0, i32 2
%56 = getelementptr inbounds [0 x %struct.node], [0 x %struct.node]* %55, i64 0, i64 100
%57 = getelementptr inbounds %struct.node, %struct.node* %56, i32 0, i32 0
%58 = load i32, i32* %57
%59 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.12, i64 0, i64 0), i32 %58)
%60 = load %struct.root*, %struct.root** %2
%61 = bitcast %struct.root* %60 to i8*
%62 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.13, i64 0, i64 0), i64 8)
%63 = call i8* @malloc(i64 16)
%64 = bitcast i8* %63 to %struct.root_s*
store %struct.root_s* %64, %struct.root_s** %3
%65 = call i8* @malloc(i64 160)
%66 = bitcast i8* %65 to %struct.node*
%67 = load %struct.root_s*, %struct.root_s** %3
%68 = getelementptr inbounds %struct.root_s, %struct.root_s* %67, i32 0, i32 2
store %struct.node* %66, %struct.node** %68
%69 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.14, i64 0, i64 0), i64 8)
%70 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.15, i64 0, i64 0), i64 16)
%71 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.16, i64 0, i64 0), i64 8)
%72 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.17, i64 0, i64 0), i64 8)
%73 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.18, i64 0, i64 0), i64 8)
%74 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.19, i64 0, i64 0), i64 8)
%75 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.20, i64 0, i64 0), i64 8)
%76 = load %struct.root_s*, %struct.root_s** %3
%77 = getelementptr inbounds %struct.root_s, %struct.root_s* %76, i32 0, i32 2
%78 = load %struct.node*, %struct.node** %77
%79 = getelementptr inbounds %struct.node, %struct.node* %78, i64 0
%80 = getelementptr inbounds %struct.node, %struct.node* %79, i32 0, i32 0
store i32 0, i32* %80
%81 = load %struct.root_s*, %struct.root_s** %3
%82 = getelementptr inbounds %struct.root_s, %struct.root_s* %81, i32 0, i32 2
%83 = load %struct.node*, %struct.node** %82
%84 = getelementptr inbounds %struct.node, %struct.node* %83, i64 19
%85 = getelementptr inbounds %struct.node, %struct.node* %84, i32 0, i32 0
store i32 1, i32* %85
%86 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.17, i64 0, i64 0), i64 8)
%87 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.18, i64 0, i64 0), i64 8)
%88 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.19, i64 0, i64 0), i64 8)
%89 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.20, i64 0, i64 0), i64 8)
%90 = load %struct.root_s*, %struct.root_s** %3
%91 = getelementptr inbounds %struct.root_s, %struct.root_s* %90, i32 0, i32 2
%92 = load %struct.node*, %struct.node** %91
%93 = getelementptr inbounds %struct.node, %struct.node* %92, i64 0
%94 = getelementptr inbounds %struct.node, %struct.node* %93, i32 0, i32 0
%95 = load i32, i32* %94
%96 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.21, i64 0, i64 0), i32 %95)
%97 = load %struct.root_s*, %struct.root_s** %3
%98 = getelementptr inbounds %struct.root_s, %struct.root_s* %97, i32 0, i32 2
%99 = load %struct.node*, %struct.node** %98
%100 = getelementptr inbounds %struct.node, %struct.node* %99, i64 19
%101 = getelementptr inbounds %struct.node, %struct.node* %100, i32 0, i32 0
%102 = load i32, i32* %101
%103 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.22, i64 0, i64 0), i32 %102)
%104 = load %struct.root_s*, %struct.root_s** %3
%105 = getelementptr inbounds %struct.root_s, %struct.root_s* %104, i32 0, i32 2
%106 = load %struct.node*, %struct.node** %105
%107 = getelementptr inbounds %struct.node, %struct.node* %106, i64 21
%108 = getelementptr inbounds %struct.node, %struct.node* %107, i32 0, i32 0
%109 = load i32, i32* %108
%110 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.23, i64 0, i64 0), i32 %109)
%111 = load %struct.root_s*, %struct.root_s** %3
%112 = getelementptr inbounds %struct.root_s, %struct.root_s* %111, i32 0, i32 2
%113 = load %struct.node*, %struct.node** %112
%114 = getelementptr inbounds %struct.node, %struct.node* %113, i64 100
%115 = getelementptr inbounds %struct.node, %struct.node* %114, i32 0, i32 0
%116 = load i32, i32* %115
%117 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.24, i64 0, i64 0), i32 %116)
%118 = load %struct.root_s*, %struct.root_s** %3
%119 = getelementptr inbounds %struct.root_s, %struct.root_s* %118, i32 0, i32 2
%120 = load %struct.node*, %struct.node** %119
%121 = bitcast %struct.node* %120 to i8*
%122 = load %struct.root_s*, %struct.root_s** %3
%123 = bitcast %struct.root_s* %122 to i8*
%124 = bitcast %struct.root_v* %4 to i8*
%125 = bitcast i8* %124 to %struct.root_v*
%126 = getelementptr inbounds %struct.root_v, %struct.root_v* %125, i32 0, i32 0
store i32 1, i32* %126
%127 = getelementptr inbounds %struct.root_v, %struct.root_v* %125, i32 0, i32 1
store i32 2, i32* %127
%128 = getelementptr inbounds %struct.root_v, %struct.root_v* %125, i32 0, i32 2
%129 = getelementptr inbounds [5 x %struct.node], [5 x %struct.node]* %128, i32 0, i32 0
%130 = getelementptr inbounds %struct.node, %struct.node* %129, i32 0, i32 0
store i32 3, i32* %130
%131 = getelementptr inbounds %struct.node, %struct.node* %129, i32 0, i32 1
store i32 4, i32* %131
%132 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.25, i64 0, i64 0), i64 48)
%133 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.26, i64 0, i64 0), i64 48)
%134 = getelementptr inbounds %struct.root_v, %struct.root_v* %4, i32 0, i32 2
%135 = getelementptr inbounds [5 x %struct.node], [5 x %struct.node]* %134, i64 0, i64 0
%136 = getelementptr inbounds %struct.node, %struct.node* %135, i32 0, i32 0
%137 = load i32, i32* %136
%138 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.27, i64 0, i64 0), i32 %137)
%139 = getelementptr inbounds %struct.root_v, %struct.root_v* %4, i32 0, i32 2
%140 = getelementptr inbounds [5 x %struct.node], [5 x %struct.node]* %139, i64 0, i64 1
%141 = getelementptr inbounds %struct.node, %struct.node* %140, i32 0, i32 0
%142 = load i32, i32* %141
%143 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.28, i64 0, i64 0), i32 %142)
ret i32 0
}

LLVM IR (-O2):
%struct.root = type { i32, i32, [0 x %struct.node] }
%struct.node = type { i32, i32 }
%struct.root_s = type { i32, i32, %struct.node* }
@.str = [17 x i8] c"sizeof root: %d\0A\00"
@.str.1 = [19 x i8] c"\0Asizeof hroot: %d\0A\00"
@.str.2 = [18 x i8] c"sizeof hroot: %d\0A\00"
@.str.3 = [19 x i8] c"sizeof *hroot: %d\0A\00"
@.str.4 = [25 x i8] c"sizeof hroot->nodes: %d\0A\00"
@.str.5 = [28 x i8] c"sizeof hroot->nodes[0]: %d\0A\00"
@.str.6 = [29 x i8] c"sizeof hroot->nodes[19]: %d\0A\00"
@.str.7 = [29 x i8] c"sizeof hroot->nodes[21]: %d\0A\00"
@.str.8 = [30 x i8] c"sizeof hroot->nodes[100]: %d\0A\00"
@.str.9 = [26 x i8] c"hroot->nodes[0].hash: %d\0A\00"
@.str.10 = [27 x i8] c"hroot->nodes[19].hash: %d\0A\00"
@.str.11 = [27 x i8] c"hroot->nodes[21].hash: %d\0A\00"
@.str.12 = [28 x i8] c"hroot->nodes[100].hash: %d\0A\00"
@.str.13 = [19 x i8] c"\0Asizeof sroot: %d\0A\00"
@.str.14 = [18 x i8] c"sizeof sroot: %d\0A\00"
@.str.15 = [19 x i8] c"sizeof *sroot: %d\0A\00"
@.str.16 = [25 x i8] c"sizeof sroot->nodes: %d\0A\00"
@.str.17 = [28 x i8] c"sizeof sroot->nodes[0]: %d\0A\00"
@.str.18 = [29 x i8] c"sizeof sroot->nodes[19]: %d\0A\00"
@.str.19 = [29 x i8] c"sizeof sroot->nodes[21]: %d\0A\00"
@.str.20 = [30 x i8] c"sizeof sroot->nodes[100]: %d\0A\00"
@.str.21 = [26 x i8] c"sroot->nodes[0].hash: %d\0A\00"
@.str.22 = [27 x i8] c"sroot->nodes[19].hash: %d\0A\00"
@.str.23 = [27 x i8] c"sroot->nodes[21].hash: %d\0A\00"
@.str.24 = [28 x i8] c"sroot->nodes[100].hash: %d\0A\00"
@.str.25 = [19 x i8] c"\0Asizeof rootv: %d\0A\00"
@.str.26 = [18 x i8] c"sizeof vroot: %d\0A\00"
@.str.27 = [26 x i8] c"vroot->nodes[0].hash: %d\0A\00"
@.str.28 = [26 x i8] c"vroot->nodes[1].hash: %d\0A\00"
define i32 @main() {
%1 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str, i64 0, i64 0), i64 8)
%2 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @.str.1, i64 0, i64 0), i64 8)
%3 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @.str.2, i64 0, i64 0), i64 8)
%4 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @.str.3, i64 0, i64 0), i64 8)
%5 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([25 x i8], [25 x i8]* @.str.4, i64 0, i64 0), i64 0)
%6 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @.str.5, i64 0, i64 0), i64 8)
%7 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([29 x i8], [29 x i8]* @.str.6, i64 0, i64 0), i64 8)
%8 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([29 x i8], [29 x i8]* @.str.7, i64 0, i64 0), i64 8)
%9 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([30 x i8], [30 x i8]* @.str.8, i64 0, i64 0), i64 8)
%10 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @.str.5, i64 0, i64 0), i64 8)
%11 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([29 x i8], [29 x i8]* @.str.6, i64 0, i64 0), i64 8)
%12 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([29 x i8], [29 x i8]* @.str.7, i64 0, i64 0), i64 8)
%13 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([30 x i8], [30 x i8]* @.str.8, i64 0, i64 0), i64 8)
%14 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([26 x i8], [26 x i8]* @.str.9, i64 0, i64 0), i32 0)
%15 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([27 x i8], [27 x i8]* @.str.10, i64 0, i64 0), i32 1)
%16 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([27 x i8], [27 x i8]* @.str.11, i64 0, i64 0), i32 2)
%17 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @.str.12, i64 0, i64 0), i32 3)
%18 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @.str.13, i64 0, i64 0), i64 8)
%19 = tail call dereferenceable_or_null(160) i8* @malloc(i64 160)
%20 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @.str.14, i64 0, i64 0), i64 8)
%21 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @.str.15, i64 0, i64 0), i64 16)
%22 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([25 x i8], [25 x i8]* @.str.16, i64 0, i64 0), i64 8)
%23 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @.str.17, i64 0, i64 0), i64 8)
%24 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([29 x i8], [29 x i8]* @.str.18, i64 0, i64 0), i64 8)
%25 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([29 x i8], [29 x i8]* @.str.19, i64 0, i64 0), i64 8)
%26 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([30 x i8], [30 x i8]* @.str.20, i64 0, i64 0), i64 8)
%27 = bitcast i8* %19 to %struct.node*
%28 = getelementptr inbounds %struct.node, %struct.node* %27, i64 0, i32 0
store i32 0, i32* %28
%29 = getelementptr inbounds %struct.node, %struct.node* %27, i64 19, i32 0
store i32 1, i32* %29
%30 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @.str.17, i64 0, i64 0), i64 8)
%31 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([29 x i8], [29 x i8]* @.str.18, i64 0, i64 0), i64 8)
%32 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([29 x i8], [29 x i8]* @.str.19, i64 0, i64 0), i64 8)
%33 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([30 x i8], [30 x i8]* @.str.20, i64 0, i64 0), i64 8)
%34 = load i32, i32* %28
%35 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([26 x i8], [26 x i8]* @.str.21, i64 0, i64 0), i32 %34)
%36 = load i32, i32* %29
%37 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([27 x i8], [27 x i8]* @.str.22, i64 0, i64 0), i32 %36)
%38 = getelementptr inbounds %struct.node, %struct.node* %27, i64 21, i32 0
%39 = load i32, i32* %38
%40 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([27 x i8], [27 x i8]* @.str.23, i64 0, i64 0), i32 %39)
%41 = getelementptr inbounds %struct.node, %struct.node* %27, i64 100, i32 0
%42 = load i32, i32* %41
%43 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @.str.24, i64 0, i64 0), i32 %42)
tail call void @free(i8* %19)
%44 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @.str.25, i64 0, i64 0), i64 48)
%45 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @.str.26, i64 0, i64 0), i64 48)
%46 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([26 x i8], [26 x i8]* @.str.27, i64 0, i64 0), i32 3)
%47 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([26 x i8], [26 x i8]* @.str.28, i64 0, i64 0), i32 0)
ret i32 0
}