#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 EXIT_SUCCESS;
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ strcpy(char *, char *);
int main(void) {
  struct Publisher {
    char name[30];
    char address[100];
    char shopping_center_tel[20];
    struct {
      char name[30];
      char genre[30];
      int floor;
      int store_nr;
      struct {
        float price;
        int general_item_code;
        union {
          struct {
            char title[50];
            char author[50];
            int number_of_pages;
          } book;
          struct {
            char type[50];
            int size;
            char color[50];
          } clothing;
          struct {
            char model_name[50];
            int ram;
            int cpu_speed;
            int hd_capacity;
            _Bool printer;
            _Bool scanner;
            _Bool integrated_video_card;
          } computer;
        };
      } item[10];
    } store[3];
  };
  struct Publisher sc;
  strcpy(sc.name, "Informit Publishing");
  strcpy(sc.address, "New York (USA)");
  strcpy(sc.shopping_center_tel, "123/4567890");
  strcpy(sc.store[0].name, "Addison Wesley");
  strcpy(sc.store[0].genre, "Computer Science");
  sc.store[0].item[0].general_item_code = 19982;
  sc.store[0].item[0].price = 45.00f;
  strcpy(sc.store[0].item[0].book.title, "Expert C Programming");
  strcpy(sc.store[0].item[0].book.author, "P.D.D");
  sc.store[0].item[0].book.number_of_pages = 682;
  printf("%s\n%s\n%s\n", sc.name, sc.address, sc.shopping_center_tel);
  printf("-----------------------\n");
  printf("Libro: %s di %s\nPrezzo: %.2f Euro acquistabile presso"
         "la libreria %s [%s]\n",
         sc.store[0].item[0].book.title, sc.store[0].item[0].book.author,
         sc.store[0].item[0].price, sc.store[0].name, sc.store[0].genre);
  return (EXIT_SUCCESS);
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xf00,%rsp
movl   $0x0,-0x4(%rbp)
lea    -0xf00(%rbp),%rdi
lea    0xec4(%rip),%rsi
call   1030 <strcpy@plt>
lea    -0xf00(%rbp),%rdi
add    $0x1e,%rdi
lea    0xec1(%rip),%rsi
call   1030 <strcpy@plt>
lea    -0xf00(%rbp),%rdi
add    $0x82,%rdi
lea    0xeb6(%rip),%rsi
call   1030 <strcpy@plt>
lea    -0xf00(%rbp),%rdi
add    $0x98,%rdi
lea    0xea8(%rip),%rsi
call   1030 <strcpy@plt>
lea    -0xf00(%rbp),%rdi
add    $0x98,%rdi
add    $0x1e,%rdi
lea    0xe99(%rip),%rsi
call   1030 <strcpy@plt>
movl   $0x4e0e,-0xe20(%rbp)
movss  0xe40(%rip),%xmm0
movss  %xmm0,-0xe24(%rbp)
ff
lea    -0xf00(%rbp),%rdi
add    $0x98,%rdi
add    $0x44,%rdi
add    $0x8,%rdi
lea    0xe6e(%rip),%rsi
call   1030 <strcpy@plt>
lea    -0xf00(%rbp),%rdi
add    $0x98,%rdi
add    $0x44,%rdi
add    $0x8,%rdi
add    $0x32,%rdi
lea    0xe5d(%rip),%rsi
call   1030 <strcpy@plt>
movl   $0x2aa,-0xdb8(%rbp)
lea    -0xf00(%rbp),%rsi
lea    -0xf00(%rbp),%rdx
add    $0x1e,%rdx
lea    -0xf00(%rbp),%rcx
add    $0x82,%rcx
lea    0xe2d(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xe29(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    -0xf00(%rbp),%rsi
add    $0x98,%rsi
add    $0x44,%rsi
add    $0x8,%rsi
lea    -0xf00(%rbp),%rdx
add    $0x98,%rdx
add    $0x44,%rdx
add    $0x8,%rdx
add    $0x32,%rdx
movss  -0xe24(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
lea    -0xf00(%rbp),%rcx
add    $0x98,%rcx
lea    -0xf00(%rbp),%r8
add    $0x98,%r8
add    $0x1e,%r8
lea    0xdd8(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    0x2d19(%rip),%rax
mov    (%rax),%eax
add    $0xf00,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xf08,%rsp
lea    0xeb8(%rip),%rsi
lea    0x8(%rsp),%r15
mov    %r15,%rdi
call   1030 <strcpy@plt>
lea    0x26(%rsp),%r12
lea    0xeb3(%rip),%rsi
mov    %r12,%rdi
call   1030 <strcpy@plt>
lea    0x8a(%rsp),%rbx
lea    0xeab(%rip),%rsi
mov    %rbx,%rdi
call   1030 <strcpy@plt>
lea    0xa0(%rsp),%rdi
lea    0xea0(%rip),%rsi
call   1030 <strcpy@plt>
lea    0xbe(%rsp),%r13
lea    0xe9b(%rip),%rsi
mov    %r13,%rdi
call   1030 <strcpy@plt>
movabs $0x4e0e42340000,%rax
mov    %rax,0xe4(%rsp)
lea    0xec(%rsp),%rbp
lea    0xe83(%rip),%rsi
mov    %rbp,%rdi
call   1030 <strcpy@plt>
lea    0x11e(%rsp),%r14
lea    0xe81(%rip),%rsi
mov    %r14,%rdi
call   1030 <strcpy@plt>
movl   $0x2aa,0x150(%rsp)
lea    0xe6d(%rip),%rdi
mov    %r15,%rsi
mov    %r12,%rdx
mov    %rbx,%rcx
xor    %eax,%eax
call   1050 <printf@plt>
lea    0xeaa(%rip),%rdi
call   1040 <puts@plt>
movss  0xe4(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xe47(%rip),%rdi
mov    %rbp,%rsi
mov    %r14,%rdx
lea    0xa0(%rsp),%rcx
mov    %r13,%r8
mov    $0x1,%al
call   1050 <printf@plt>
mov    0x2d94(%rip),%rax
mov    (%rax),%eax
add    $0xf08,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
%struct.Publisher = type { [30 x i8], [100 x i8], [20 x i8], [3 x %struct.anon] }
%struct.anon = type { [30 x i8], [30 x i8], i32, i32, [10 x %struct.anon.0] }
%struct.anon.0 = type { float, i32, %union.anon }
%union.anon = type { %struct.anon.2 }
%struct.anon.2 = type { [50 x i8], i32, [50 x i8] }
%struct.anon.1 = type { [50 x i8], [50 x i8], i32 }
@.str = [20 x i8] c"Informit Publishing\00"
@.str.1 = [15 x i8] c"New York (USA)\00"
@.str.2 = [12 x i8] c"123/4567890\00"
@.str.3 = [15 x i8] c"Addison Wesley\00"
@.str.4 = [17 x i8] c"Computer Science\00"
@.str.5 = [21 x i8] c"Expert C Programming\00"
@.str.6 = [6 x i8] c"P.D.D\00"
@.str.7 = [10 x i8] c"%s\0A%s\0A%s\0A\00"
@.str.8 = [25 x i8] c"-----------------------\0A\00"
@.str.9 = [74 x i8] c"Libro: %s di %s\0APrezzo: %.2f Euro acquistabile pressola libreria %s [%s]\0A\00"
@EXIT_SUCCESS = global i32 0
define i32 @main() {
%1 = alloca i32
%2 = alloca %struct.Publisher
store i32 0, i32* %1
%3 = getelementptr inbounds %struct.Publisher, %struct.Publisher* %2, i32 0, i32 0
%4 = getelementptr inbounds [30 x i8], [30 x i8]* %3, i64 0, i64 0
%5 = call i32 @strcpy(i8* %4, i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str, i64 0, i64 0))
%6 = getelementptr inbounds %struct.Publisher, %struct.Publisher* %2, i32 0, i32 1
%7 = getelementptr inbounds [100 x i8], [100 x i8]* %6, i64 0, i64 0
%8 = call i32 @strcpy(i8* %7, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.1, i64 0, i64 0))
%9 = getelementptr inbounds %struct.Publisher, %struct.Publisher* %2, i32 0, i32 2
%10 = getelementptr inbounds [20 x i8], [20 x i8]* %9, i64 0, i64 0
%11 = call i32 @strcpy(i8* %10, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.2, i64 0, i64 0))
%12 = getelementptr inbounds %struct.Publisher, %struct.Publisher* %2, i32 0, i32 3
%13 = getelementptr inbounds [3 x %struct.anon], [3 x %struct.anon]* %12, i64 0, i64 0
%14 = getelementptr inbounds %struct.anon, %struct.anon* %13, i32 0, i32 0
%15 = getelementptr inbounds [30 x i8], [30 x i8]* %14, i64 0, i64 0
%16 = call i32 @strcpy(i8* %15, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.3, i64 0, i64 0))
%17 = getelementptr inbounds %struct.Publisher, %struct.Publisher* %2, i32 0, i32 3
%18 = getelementptr inbounds [3 x %struct.anon], [3 x %struct.anon]* %17, i64 0, i64 0
%19 = getelementptr inbounds %struct.anon, %struct.anon* %18, i32 0, i32 1
%20 = getelementptr inbounds [30 x i8], [30 x i8]* %19, i64 0, i64 0
%21 = call i32 @strcpy(i8* %20, i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.4, i64 0, i64 0))
%22 = getelementptr inbounds %struct.Publisher, %struct.Publisher* %2, i32 0, i32 3
%23 = getelementptr inbounds [3 x %struct.anon], [3 x %struct.anon]* %22, i64 0, i64 0
%24 = getelementptr inbounds %struct.anon, %struct.anon* %23, i32 0, i32 4
%25 = getelementptr inbounds [10 x %struct.anon.0], [10 x %struct.anon.0]* %24, i64 0, i64 0
%26 = getelementptr inbounds %struct.anon.0, %struct.anon.0* %25, i32 0, i32 1
store i32 19982, i32* %26
%27 = getelementptr inbounds %struct.Publisher, %struct.Publisher* %2, i32 0, i32 3
%28 = getelementptr inbounds [3 x %struct.anon], [3 x %struct.anon]* %27, i64 0, i64 0
%29 = getelementptr inbounds %struct.anon, %struct.anon* %28, i32 0, i32 4
%30 = getelementptr inbounds [10 x %struct.anon.0], [10 x %struct.anon.0]* %29, i64 0, i64 0
%31 = getelementptr inbounds %struct.anon.0, %struct.anon.0* %30, i32 0, i32 0
store float 4.500000e+01, float* %31
%32 = getelementptr inbounds %struct.Publisher, %struct.Publisher* %2, i32 0, i32 3
%33 = getelementptr inbounds [3 x %struct.anon], [3 x %struct.anon]* %32, i64 0, i64 0
%34 = getelementptr inbounds %struct.anon, %struct.anon* %33, i32 0, i32 4
%35 = getelementptr inbounds [10 x %struct.anon.0], [10 x %struct.anon.0]* %34, i64 0, i64 0
%36 = getelementptr inbounds %struct.anon.0, %struct.anon.0* %35, i32 0, i32 2
%37 = bitcast %union.anon* %36 to %struct.anon.1*
%38 = getelementptr inbounds %struct.anon.1, %struct.anon.1* %37, i32 0, i32 0
%39 = getelementptr inbounds [50 x i8], [50 x i8]* %38, i64 0, i64 0
%40 = call i32 @strcpy(i8* %39, i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.5, i64 0, i64 0))
%41 = getelementptr inbounds %struct.Publisher, %struct.Publisher* %2, i32 0, i32 3
%42 = getelementptr inbounds [3 x %struct.anon], [3 x %struct.anon]* %41, i64 0, i64 0
%43 = getelementptr inbounds %struct.anon, %struct.anon* %42, i32 0, i32 4
%44 = getelementptr inbounds [10 x %struct.anon.0], [10 x %struct.anon.0]* %43, i64 0, i64 0
%45 = getelementptr inbounds %struct.anon.0, %struct.anon.0* %44, i32 0, i32 2
%46 = bitcast %union.anon* %45 to %struct.anon.1*
%47 = getelementptr inbounds %struct.anon.1, %struct.anon.1* %46, i32 0, i32 1
%48 = getelementptr inbounds [50 x i8], [50 x i8]* %47, i64 0, i64 0
%49 = call i32 @strcpy(i8* %48, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.6, i64 0, i64 0))
%50 = getelementptr inbounds %struct.Publisher, %struct.Publisher* %2, i32 0, i32 3
%51 = getelementptr inbounds [3 x %struct.anon], [3 x %struct.anon]* %50, i64 0, i64 0
%52 = getelementptr inbounds %struct.anon, %struct.anon* %51, i32 0, i32 4
%53 = getelementptr inbounds [10 x %struct.anon.0], [10 x %struct.anon.0]* %52, i64 0, i64 0
%54 = getelementptr inbounds %struct.anon.0, %struct.anon.0* %53, i32 0, i32 2
%55 = bitcast %union.anon* %54 to %struct.anon.1*
%56 = getelementptr inbounds %struct.anon.1, %struct.anon.1* %55, i32 0, i32 2
store i32 682, i32* %56
%57 = getelementptr inbounds %struct.Publisher, %struct.Publisher* %2, i32 0, i32 0
%58 = getelementptr inbounds [30 x i8], [30 x i8]* %57, i64 0, i64 0
%59 = getelementptr inbounds %struct.Publisher, %struct.Publisher* %2, i32 0, i32 1
%60 = getelementptr inbounds [100 x i8], [100 x i8]* %59, i64 0, i64 0
%61 = getelementptr inbounds %struct.Publisher, %struct.Publisher* %2, i32 0, i32 2
%62 = getelementptr inbounds [20 x i8], [20 x i8]* %61, i64 0, i64 0
%63 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.7, i64 0, i64 0), i8* %58, i8* %60, i8* %62)
%64 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.8, i64 0, i64 0))
%65 = getelementptr inbounds %struct.Publisher, %struct.Publisher* %2, i32 0, i32 3
%66 = getelementptr inbounds [3 x %struct.anon], [3 x %struct.anon]* %65, i64 0, i64 0
%67 = getelementptr inbounds %struct.anon, %struct.anon* %66, i32 0, i32 4
%68 = getelementptr inbounds [10 x %struct.anon.0], [10 x %struct.anon.0]* %67, i64 0, i64 0
%69 = getelementptr inbounds %struct.anon.0, %struct.anon.0* %68, i32 0, i32 2
%70 = bitcast %union.anon* %69 to %struct.anon.1*
%71 = getelementptr inbounds %struct.anon.1, %struct.anon.1* %70, i32 0, i32 0
%72 = getelementptr inbounds [50 x i8], [50 x i8]* %71, i64 0, i64 0
%73 = getelementptr inbounds %struct.Publisher, %struct.Publisher* %2, i32 0, i32 3
%74 = getelementptr inbounds [3 x %struct.anon], [3 x %struct.anon]* %73, i64 0, i64 0
%75 = getelementptr inbounds %struct.anon, %struct.anon* %74, i32 0, i32 4
%76 = getelementptr inbounds [10 x %struct.anon.0], [10 x %struct.anon.0]* %75, i64 0, i64 0
%77 = getelementptr inbounds %struct.anon.0, %struct.anon.0* %76, i32 0, i32 2
%78 = bitcast %union.anon* %77 to %struct.anon.1*
%79 = getelementptr inbounds %struct.anon.1, %struct.anon.1* %78, i32 0, i32 1
%80 = getelementptr inbounds [50 x i8], [50 x i8]* %79, i64 0, i64 0
%81 = getelementptr inbounds %struct.Publisher, %struct.Publisher* %2, i32 0, i32 3
%82 = getelementptr inbounds [3 x %struct.anon], [3 x %struct.anon]* %81, i64 0, i64 0
%83 = getelementptr inbounds %struct.anon, %struct.anon* %82, i32 0, i32 4
%84 = getelementptr inbounds [10 x %struct.anon.0], [10 x %struct.anon.0]* %83, i64 0, i64 0
%85 = getelementptr inbounds %struct.anon.0, %struct.anon.0* %84, i32 0, i32 0
%86 = load float, float* %85
%87 = fpext float %86 to double
%88 = getelementptr inbounds %struct.Publisher, %struct.Publisher* %2, i32 0, i32 3
%89 = getelementptr inbounds [3 x %struct.anon], [3 x %struct.anon]* %88, i64 0, i64 0
%90 = getelementptr inbounds %struct.anon, %struct.anon* %89, i32 0, i32 0
%91 = getelementptr inbounds [30 x i8], [30 x i8]* %90, i64 0, i64 0
%92 = getelementptr inbounds %struct.Publisher, %struct.Publisher* %2, i32 0, i32 3
%93 = getelementptr inbounds [3 x %struct.anon], [3 x %struct.anon]* %92, i64 0, i64 0
%94 = getelementptr inbounds %struct.anon, %struct.anon* %93, i32 0, i32 1
%95 = getelementptr inbounds [30 x i8], [30 x i8]* %94, i64 0, i64 0
%96 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([74 x i8], [74 x i8]* @.str.9, i64 0, i64 0), i8* %72, i8* %80, double %87, i8* %91, i8* %95)
%97 = load i32, i32* @EXIT_SUCCESS
ret i32 %97
}

LLVM IR (-O2):
%struct.Publisher = type { [30 x i8], [100 x i8], [20 x i8], [3 x %struct.anon] }
%struct.anon = type { [30 x i8], [30 x i8], i32, i32, [10 x %struct.anon.0] }
%struct.anon.0 = type { float, i32, %union.anon }
%union.anon = type { %struct.anon.2 }
%struct.anon.2 = type { [50 x i8], i32, [50 x i8] }
@.str = [20 x i8] c"Informit Publishing\00"
@.str.1 = [15 x i8] c"New York (USA)\00"
@.str.2 = [12 x i8] c"123/4567890\00"
@.str.3 = [15 x i8] c"Addison Wesley\00"
@.str.4 = [17 x i8] c"Computer Science\00"
@.str.5 = [21 x i8] c"Expert C Programming\00"
@.str.6 = [6 x i8] c"P.D.D\00"
@.str.7 = [10 x i8] c"%s\0A%s\0A%s\0A\00"
@.str.9 = [74 x i8] c"Libro: %s di %s\0APrezzo: %.2f Euro acquistabile pressola libreria %s [%s]\0A\00"
@EXIT_SUCCESS = global i32 0
@str = [24 x i8] c"-----------------------\00"
define i32 @main() {
%1 = alloca %struct.Publisher
%2 = getelementptr inbounds %struct.Publisher, %struct.Publisher* %1, i64 0, i32 0, i64 0
%3 = call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str, i64 0, i64 0))
%4 = getelementptr inbounds %struct.Publisher, %struct.Publisher* %1, i64 0, i32 1, i64 0
%5 = call i32 @strcpy(i8* %4, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.1, i64 0, i64 0))
%6 = getelementptr inbounds %struct.Publisher, %struct.Publisher* %1, i64 0, i32 2, i64 0
%7 = call i32 @strcpy(i8* %6, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.2, i64 0, i64 0))
%8 = getelementptr inbounds %struct.Publisher, %struct.Publisher* %1, i64 0, i32 3, i64 0, i32 0, i64 0
%9 = call i32 @strcpy(i8* %8, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.3, i64 0, i64 0))
%10 = getelementptr inbounds %struct.Publisher, %struct.Publisher* %1, i64 0, i32 3, i64 0, i32 1, i64 0
%11 = call i32 @strcpy(i8* %10, i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.4, i64 0, i64 0))
%12 = getelementptr inbounds %struct.Publisher, %struct.Publisher* %1, i64 0, i32 3, i64 0, i32 4, i64 0, i32 1
store i32 19982, i32* %12
%13 = getelementptr inbounds %struct.Publisher, %struct.Publisher* %1, i64 0, i32 3, i64 0, i32 4, i64 0, i32 0
store float 4.500000e+01, float* %13
%14 = getelementptr inbounds %struct.Publisher, %struct.Publisher* %1, i64 0, i32 3, i64 0, i32 4, i64 0, i32 2, i32 0, i32 0, i64 0
%15 = call i32 @strcpy(i8* %14, i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.5, i64 0, i64 0))
%16 = getelementptr inbounds %struct.Publisher, %struct.Publisher* %1, i64 0, i32 3, i64 0, i32 4, i64 0, i32 2, i32 0, i32 0, i64 50
%17 = call i32 @strcpy(i8* %16, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.6, i64 0, i64 0))
%18 = getelementptr inbounds %struct.Publisher, %struct.Publisher* %1, i64 0, i32 3, i64 0, i32 4, i64 0, i32 2, i32 0, i32 2, i64 44
%19 = bitcast i8* %18 to i32*
store i32 682, i32* %19
%20 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @.str.7, i64 0, i64 0), i8* %2, i8* %4, i8* %6)
%21 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([24 x i8], [24 x i8]* @str, i64 0, i64 0))
%22 = load float, float* %13
%23 = fpext float %22 to double
%24 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([74 x i8], [74 x i8]* @.str.9, i64 0, i64 0), i8* %14, i8* %16, double %23, i8* %8, i8* %10)
%25 = load i32, i32* @EXIT_SUCCESS
ret i32 %25
}