int main(void) {
  char lave = 'B';
  unsigned char lavish = 10;
  short lax = 20;
  unsigned short lecherous = 30;
  long lechery = 40;
  unsigned long lectern = 50;
  float leeway = 60;
  double legacy = 70;
  signed char lemonade = 35;
  const char laconic = 'A';
  const unsigned char laggard = 1;
  const short lagoon = 2;
  const unsigned short laity = 3;
  const long lambent = 4;
  const unsigned long laminated = 5;
  const float lampoon = 6;
  const double languid = 7;
  const char *legend = &lave;
  const unsigned char *legerdemain = &lavish;
  const short *leniency = &lax;
  const unsigned short *leonine = &lecherous;
  const long *lesion = &lechery;
  const unsigned long *lethal = &lectern;
  const float *lethargic = &leeway;
  const double *levity = &legacy;
  const char *const lewd = &laconic;
  const unsigned char *const lexicographer = &laggard;
  const short *const lexicon = &lagoon;
  const unsigned short *const liaison = &laity;
  const long *const libation = &lambent;
  const unsigned long *const libelous = &laminated;
  const float *const libertine = &lampoon;
  const double *const libidinous = &languid;
  char const *languish = &laconic;
  unsigned char const *languor = &laggard;
  short const *lank = &lagoon;
  unsigned short const *lapidary = &laity;
  long const *larceny = &lambent;
  unsigned long const *largess = &laminated;
  float const *lascivious = &lampoon;
  double const *lassitude = &languid;
  char *const lamprey = &lave;
  unsigned char *const lariat = &lavish;
  short *const laudanum = &lax;
  unsigned short *const lecithin = &lecherous;
  long *const leviathan = &lechery;
  unsigned long *const libretto = &lectern;
  float *const lissome = &leeway;
  double *const locust = &legacy;
  volatile char vox = 'X';
  volatile unsigned char victuals = 13;
  volatile short vixen = 200;
  volatile unsigned short vitriol = 300;
  volatile long vellum = 1000;
  volatile unsigned long valve = 2000;
  volatile float vacuity = 3.0;
  volatile double vertigo = 10.3;
  volatile char *vampire = &vox;
  volatile unsigned char *viper = &victuals;
  volatile short *vigour = &vixen;
  volatile unsigned short *vapour = &vitriol;
  volatile long *ventricle = &vellum;
  volatile unsigned long *vigintillion = &valve;
  volatile float *vocation = &vacuity;
  volatile double *veracity = &vertigo;
  volatile char *volatile vapidity = &vox;
  volatile unsigned char *volatile velocity = &victuals;
  volatile short *volatile veneer = &vixen;
  volatile unsigned short *volatile video = &vitriol;
  volatile long *volatile vacuum = &vellum;
  volatile unsigned long *volatile veniality = &valve;
  volatile float *volatile vitality = &vacuity;
  volatile double *volatile voracity = &vertigo;
  const volatile char victor = 'Y';
  const volatile unsigned char vicar = 11;
  const volatile char *victory = &victor;
  const volatile unsigned char *vicarage = &vicar;
  volatile char *const vein = &vox;
  volatile unsigned char *const vogue = &victuals;
  const volatile char *const cavern = &victor;
  const volatile unsigned char *const coverlet = &vicar;
  const char *volatile caveat = &laconic;
  const unsigned char *volatile covenant = &laggard;
  const volatile char *volatile vizier = &victor;
  const volatile unsigned char *volatile vanadium = &vicar;
  char *const volatile vane = &lave;
  unsigned char *const volatile veldt = &lavish;
  const char *const volatile cove = &laconic;
  const unsigned char *const volatile cavity = &laggard;
  volatile char *const volatile vagus = &vox;
  volatile unsigned char *const volatile vagrancy = &victuals;
  const volatile char *const volatile vagary = &victor;
  const volatile unsigned char *const volatile vendor = &vicar;
  struct crass {
    char *const ptr;
  } crass;
  struct crisp {
    char *const *ptr;
  } crisp;
  marker1();
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x2b0,%rsp
movl   $0x0,-0x4(%rbp)
movb   $0x42,-0x5(%rbp)
movb   $0xa,-0x6(%rbp)
movw   $0x14,-0x8(%rbp)
movw   $0x1e,-0xa(%rbp)
movq   $0x28,-0x18(%rbp)
movq   $0x32,-0x20(%rbp)
movss  0xed2(%rip),%xmm0
movss  %xmm0,-0x24(%rbp)
movsd  0xeb5(%rip),%xmm0
movsd  %xmm0,-0x30(%rbp)
movb   $0x23,-0x31(%rbp)
movb   $0x41,-0x32(%rbp)
movb   $0x1,-0x33(%rbp)
movw   $0x2,-0x36(%rbp)
movw   $0x3,-0x38(%rbp)
movq   $0x4,-0x40(%rbp)
movq   $0x5,-0x48(%rbp)
movss  0xe8c(%rip),%xmm0
movss  %xmm0,-0x4c(%rbp)
movsd  0xe6b(%rip),%xmm0
movsd  %xmm0,-0x58(%rbp)
lea    -0x5(%rbp),%rax
mov    %rax,-0x60(%rbp)
lea    -0x6(%rbp),%rax
mov    %rax,-0x68(%rbp)
lea    -0x8(%rbp),%rax
mov    %rax,-0x70(%rbp)
lea    -0xa(%rbp),%rax
mov    %rax,-0x78(%rbp)
lea    -0x18(%rbp),%rax
mov    %rax,-0x80(%rbp)
lea    -0x20(%rbp),%rax
mov    %rax,-0x88(%rbp)
lea    -0x24(%rbp),%rax
mov    %rax,-0x90(%rbp)
lea    -0x30(%rbp),%rax
mov    %rax,-0x98(%rbp)
lea    -0x32(%rbp),%rax
mov    %rax,-0xa0(%rbp)
lea    -0x33(%rbp),%rax
mov    %rax,-0xa8(%rbp)
lea    -0x36(%rbp),%rax
mov    %rax,-0xb0(%rbp)
lea    -0x38(%rbp),%rax
mov    %rax,-0xb8(%rbp)
lea    -0x40(%rbp),%rax
mov    %rax,-0xc0(%rbp)
lea    -0x48(%rbp),%rax
mov    %rax,-0xc8(%rbp)
lea    -0x4c(%rbp),%rax
mov    %rax,-0xd0(%rbp)
lea    -0x58(%rbp),%rax
mov    %rax,-0xd8(%rbp)
lea    -0x32(%rbp),%rax
mov    %rax,-0xe0(%rbp)
lea    -0x33(%rbp),%rax
mov    %rax,-0xe8(%rbp)
lea    -0x36(%rbp),%rax
mov    %rax,-0xf0(%rbp)
lea    -0x38(%rbp),%rax
mov    %rax,-0xf8(%rbp)
lea    -0x40(%rbp),%rax
mov    %rax,-0x100(%rbp)
lea    -0x48(%rbp),%rax
mov    %rax,-0x108(%rbp)
lea    -0x4c(%rbp),%rax
mov    %rax,-0x110(%rbp)
lea    -0x58(%rbp),%rax
mov    %rax,-0x118(%rbp)
lea    -0x5(%rbp),%rax
mov    %rax,-0x120(%rbp)
lea    -0x6(%rbp),%rax
mov    %rax,-0x128(%rbp)
lea    -0x8(%rbp),%rax
mov    %rax,-0x130(%rbp)
lea    -0xa(%rbp),%rax
mov    %rax,-0x138(%rbp)
lea    -0x18(%rbp),%rax
mov    %rax,-0x140(%rbp)
lea    -0x20(%rbp),%rax
mov    %rax,-0x148(%rbp)
lea    -0x24(%rbp),%rax
mov    %rax,-0x150(%rbp)
lea    -0x30(%rbp),%rax
mov    %rax,-0x158(%rbp)
movb   $0x58,-0x159(%rbp)
movb   $0xd,-0x15a(%rbp)
movw   $0xc8,-0x15c(%rbp)
movw   $0x12c,-0x15e(%rbp)
2c 01
movq   $0x3e8,-0x168(%rbp)
movq   $0x7d0,-0x170(%rbp)
movss  0xce7(%rip),%xmm0
movss  %xmm0,-0x174(%rbp)
ff
movsd  0xcbf(%rip),%xmm0
movsd  %xmm0,-0x180(%rbp)
ff
lea    -0x159(%rbp),%rax
mov    %rax,-0x188(%rbp)
lea    -0x15a(%rbp),%rax
mov    %rax,-0x190(%rbp)
lea    -0x15c(%rbp),%rax
mov    %rax,-0x198(%rbp)
lea    -0x15e(%rbp),%rax
mov    %rax,-0x1a0(%rbp)
lea    -0x168(%rbp),%rax
mov    %rax,-0x1a8(%rbp)
lea    -0x170(%rbp),%rax
mov    %rax,-0x1b0(%rbp)
lea    -0x174(%rbp),%rax
mov    %rax,-0x1b8(%rbp)
lea    -0x180(%rbp),%rax
mov    %rax,-0x1c0(%rbp)
lea    -0x159(%rbp),%rax
mov    %rax,-0x1c8(%rbp)
lea    -0x15a(%rbp),%rax
mov    %rax,-0x1d0(%rbp)
lea    -0x15c(%rbp),%rax
mov    %rax,-0x1d8(%rbp)
lea    -0x15e(%rbp),%rax
mov    %rax,-0x1e0(%rbp)
lea    -0x168(%rbp),%rax
mov    %rax,-0x1e8(%rbp)
lea    -0x170(%rbp),%rax
mov    %rax,-0x1f0(%rbp)
lea    -0x174(%rbp),%rax
mov    %rax,-0x1f8(%rbp)
lea    -0x180(%rbp),%rax
mov    %rax,-0x200(%rbp)
movb   $0x59,-0x201(%rbp)
movb   $0xb,-0x202(%rbp)
lea    -0x201(%rbp),%rax
mov    %rax,-0x210(%rbp)
lea    -0x202(%rbp),%rax
mov    %rax,-0x218(%rbp)
lea    -0x159(%rbp),%rax
mov    %rax,-0x220(%rbp)
lea    -0x15a(%rbp),%rax
mov    %rax,-0x228(%rbp)
lea    -0x201(%rbp),%rax
mov    %rax,-0x230(%rbp)
lea    -0x202(%rbp),%rax
mov    %rax,-0x238(%rbp)
lea    -0x32(%rbp),%rax
mov    %rax,-0x240(%rbp)
lea    -0x33(%rbp),%rax
mov    %rax,-0x248(%rbp)
lea    -0x201(%rbp),%rax
mov    %rax,-0x250(%rbp)
lea    -0x202(%rbp),%rax
mov    %rax,-0x258(%rbp)
lea    -0x5(%rbp),%rax
mov    %rax,-0x260(%rbp)
lea    -0x6(%rbp),%rax
mov    %rax,-0x268(%rbp)
lea    -0x32(%rbp),%rax
mov    %rax,-0x270(%rbp)
lea    -0x33(%rbp),%rax
mov    %rax,-0x278(%rbp)
lea    -0x159(%rbp),%rax
mov    %rax,-0x280(%rbp)
lea    -0x15a(%rbp),%rax
mov    %rax,-0x288(%rbp)
lea    -0x201(%rbp),%rax
mov    %rax,-0x290(%rbp)
lea    -0x202(%rbp),%rax
mov    %rax,-0x298(%rbp)
mov    $0x0,%al
call   1030 <marker1@plt>
xor    %eax,%eax
add    $0x2b0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
sub    $0xc8,%rsp
movb   $0x42,0x7(%rsp)
movb   $0xa,0x6(%rsp)
movb   $0x41,0x5(%rsp)
movb   $0x1,0x4(%rsp)
movb   $0x58,0x3(%rsp)
movb   $0xd,0x2(%rsp)
movw   $0xc8,0xa(%rsp)
movw   $0x12c,0x8(%rsp)
movq   $0x3e8,0x20(%rsp)
movq   $0x7d0,0x18(%rsp)
movl   $0x40400000,0xc(%rsp)
40
movabs $0x402499999999999a,%rax
99 24 40
mov    %rax,0x10(%rsp)
lea    0x3(%rsp),%r8
mov    %r8,0xc0(%rsp)
lea    0x2(%rsp),%r9
mov    %r9,0xb8(%rsp)
lea    0xa(%rsp),%rdx
mov    %rdx,0xb0(%rsp)
lea    0x8(%rsp),%rdx
mov    %rdx,0xa8(%rsp)
lea    0x20(%rsp),%rdx
mov    %rdx,0xa0(%rsp)
lea    0x18(%rsp),%rdx
mov    %rdx,0x98(%rsp)
lea    0xc(%rsp),%rdx
mov    %rdx,0x90(%rsp)
lea    0x10(%rsp),%rdx
mov    %rdx,0x88(%rsp)
movb   $0x59,0x1(%rsp)
movb   $0xb,(%rsp)
lea    0x5(%rsp),%rdx
mov    %rdx,0x80(%rsp)
lea    0x4(%rsp),%rsi
mov    %rsi,0x78(%rsp)
lea    0x1(%rsp),%rdi
mov    %rdi,0x70(%rsp)
mov    %rsp,%rax
mov    %rax,0x68(%rsp)
lea    0x7(%rsp),%rcx
mov    %rcx,0x60(%rsp)
lea    0x6(%rsp),%rcx
mov    %rcx,0x58(%rsp)
mov    %rdx,0x50(%rsp)
mov    %rsi,0x48(%rsp)
mov    %r8,0x40(%rsp)
mov    %r9,0x38(%rsp)
mov    %rdi,0x30(%rsp)
mov    %rax,0x28(%rsp)
xor    %eax,%eax
call   1030 <marker1@plt>
xor    %eax,%eax
add    $0xc8,%rsp
ret

LLVM IR (-O0):
%struct.crass = type { i8* }
%struct.crisp = type { i8** }
define i32 @main() {
%1 = alloca i32
%2 = alloca i8
%3 = alloca i8
%4 = alloca i16
%5 = alloca i16
%6 = alloca i64
%7 = alloca i64
%8 = alloca float
%9 = alloca double
%10 = alloca i8
%11 = alloca i8
%12 = alloca i8
%13 = alloca i16
%14 = alloca i16
%15 = alloca i64
%16 = alloca i64
%17 = alloca float
%18 = alloca double
%19 = alloca i8*
%20 = alloca i8*
%21 = alloca i16*
%22 = alloca i16*
%23 = alloca i64*
%24 = alloca i64*
%25 = alloca float*
%26 = alloca double*
%27 = alloca i8*
%28 = alloca i8*
%29 = alloca i16*
%30 = alloca i16*
%31 = alloca i64*
%32 = alloca i64*
%33 = alloca float*
%34 = alloca double*
%35 = alloca i8*
%36 = alloca i8*
%37 = alloca i16*
%38 = alloca i16*
%39 = alloca i64*
%40 = alloca i64*
%41 = alloca float*
%42 = alloca double*
%43 = alloca i8*
%44 = alloca i8*
%45 = alloca i16*
%46 = alloca i16*
%47 = alloca i64*
%48 = alloca i64*
%49 = alloca float*
%50 = alloca double*
%51 = alloca i8
%52 = alloca i8
%53 = alloca i16
%54 = alloca i16
%55 = alloca i64
%56 = alloca i64
%57 = alloca float
%58 = alloca double
%59 = alloca i8*
%60 = alloca i8*
%61 = alloca i16*
%62 = alloca i16*
%63 = alloca i64*
%64 = alloca i64*
%65 = alloca float*
%66 = alloca double*
%67 = alloca i8*
%68 = alloca i8*
%69 = alloca i16*
%70 = alloca i16*
%71 = alloca i64*
%72 = alloca i64*
%73 = alloca float*
%74 = alloca double*
%75 = alloca i8
%76 = alloca i8
%77 = alloca i8*
%78 = alloca i8*
%79 = alloca i8*
%80 = alloca i8*
%81 = alloca i8*
%82 = alloca i8*
%83 = alloca i8*
%84 = alloca i8*
%85 = alloca i8*
%86 = alloca i8*
%87 = alloca i8*
%88 = alloca i8*
%89 = alloca i8*
%90 = alloca i8*
%91 = alloca i8*
%92 = alloca i8*
%93 = alloca i8*
%94 = alloca i8*
%95 = alloca %struct.crass
%96 = alloca %struct.crisp
store i32 0, i32* %1
store i8 66, i8* %2
store i8 10, i8* %3
store i16 20, i16* %4
store i16 30, i16* %5
store i64 40, i64* %6
store i64 50, i64* %7
store float 6.000000e+01, float* %8
store double 7.000000e+01, double* %9
store i8 35, i8* %10
store i8 65, i8* %11
store i8 1, i8* %12
store i16 2, i16* %13
store i16 3, i16* %14
store i64 4, i64* %15
store i64 5, i64* %16
store float 6.000000e+00, float* %17
store double 7.000000e+00, double* %18
store i8* %2, i8** %19
store i8* %3, i8** %20
store i16* %4, i16** %21
store i16* %5, i16** %22
store i64* %6, i64** %23
store i64* %7, i64** %24
store float* %8, float** %25
store double* %9, double** %26
store i8* %11, i8** %27
store i8* %12, i8** %28
store i16* %13, i16** %29
store i16* %14, i16** %30
store i64* %15, i64** %31
store i64* %16, i64** %32
store float* %17, float** %33
store double* %18, double** %34
store i8* %11, i8** %35
store i8* %12, i8** %36
store i16* %13, i16** %37
store i16* %14, i16** %38
store i64* %15, i64** %39
store i64* %16, i64** %40
store float* %17, float** %41
store double* %18, double** %42
store i8* %2, i8** %43
store i8* %3, i8** %44
store i16* %4, i16** %45
store i16* %5, i16** %46
store i64* %6, i64** %47
store i64* %7, i64** %48
store float* %8, float** %49
store double* %9, double** %50
store volatile i8 88, i8* %51
store volatile i8 13, i8* %52
store volatile i16 200, i16* %53
store volatile i16 300, i16* %54
store volatile i64 1000, i64* %55
store volatile i64 2000, i64* %56
store volatile float 3.000000e+00, float* %57
store volatile double 1.030000e+01, double* %58
store i8* %51, i8** %59
store i8* %52, i8** %60
store i16* %53, i16** %61
store i16* %54, i16** %62
store i64* %55, i64** %63
store i64* %56, i64** %64
store float* %57, float** %65
store double* %58, double** %66
store volatile i8* %51, i8** %67
store volatile i8* %52, i8** %68
store volatile i16* %53, i16** %69
store volatile i16* %54, i16** %70
store volatile i64* %55, i64** %71
store volatile i64* %56, i64** %72
store volatile float* %57, float** %73
store volatile double* %58, double** %74
store volatile i8 89, i8* %75
store volatile i8 11, i8* %76
store i8* %75, i8** %77
store i8* %76, i8** %78
store i8* %51, i8** %79
store i8* %52, i8** %80
store i8* %75, i8** %81
store i8* %76, i8** %82
store volatile i8* %11, i8** %83
store volatile i8* %12, i8** %84
store volatile i8* %75, i8** %85
store volatile i8* %76, i8** %86
store volatile i8* %2, i8** %87
store volatile i8* %3, i8** %88
store volatile i8* %11, i8** %89
store volatile i8* %12, i8** %90
store volatile i8* %51, i8** %91
store volatile i8* %52, i8** %92
store volatile i8* %75, i8** %93
store volatile i8* %76, i8** %94
%97 = call i32 (...) @marker1()
ret i32 0
}

LLVM IR (-O2):
define i32 @main() {
%1 = alloca i8
%2 = alloca i8
%3 = alloca i8
%4 = alloca i8
%5 = alloca i8
%6 = alloca i8
%7 = alloca i16
%8 = alloca i16
%9 = alloca i64
%10 = alloca i64
%11 = alloca float
%12 = alloca double
%13 = alloca i8*
%14 = alloca i8*
%15 = alloca i16*
%16 = alloca i16*
%17 = alloca i64*
%18 = alloca i64*
%19 = alloca float*
%20 = alloca double*
%21 = alloca i8
%22 = alloca i8
%23 = alloca i8*
%24 = alloca i8*
%25 = alloca i8*
%26 = alloca i8*
%27 = alloca i8*
%28 = alloca i8*
%29 = alloca i8*
%30 = alloca i8*
%31 = alloca i8*
%32 = alloca i8*
%33 = alloca i8*
%34 = alloca i8*
store i8 66, i8* %1
store i8 10, i8* %2
store i8 65, i8* %3
store i8 1, i8* %4
store volatile i8 88, i8* %5
store volatile i8 13, i8* %6
%35 = bitcast i16* %7 to i8*
store volatile i16 200, i16* %7
%36 = bitcast i16* %8 to i8*
store volatile i16 300, i16* %8
%37 = bitcast i64* %9 to i8*
store volatile i64 1000, i64* %9
%38 = bitcast i64* %10 to i8*
store volatile i64 2000, i64* %10
%39 = bitcast float* %11 to i8*
store volatile float 3.000000e+00, float* %11
%40 = bitcast double* %12 to i8*
store volatile double 1.030000e+01, double* %12
%41 = bitcast i8** %13 to i8*
store volatile i8* %5, i8** %13
%42 = bitcast i8** %14 to i8*
store volatile i8* %6, i8** %14
%43 = bitcast i16** %15 to i8*
store volatile i16* %7, i16** %15
%44 = bitcast i16** %16 to i8*
store volatile i16* %8, i16** %16
%45 = bitcast i64** %17 to i8*
store volatile i64* %9, i64** %17
%46 = bitcast i64** %18 to i8*
store volatile i64* %10, i64** %18
%47 = bitcast float** %19 to i8*
store volatile float* %11, float** %19
%48 = bitcast double** %20 to i8*
store volatile double* %12, double** %20
store volatile i8 89, i8* %21
store volatile i8 11, i8* %22
%49 = bitcast i8** %23 to i8*
store volatile i8* %3, i8** %23
%50 = bitcast i8** %24 to i8*
store volatile i8* %4, i8** %24
%51 = bitcast i8** %25 to i8*
store volatile i8* %21, i8** %25
%52 = bitcast i8** %26 to i8*
store volatile i8* %22, i8** %26
%53 = bitcast i8** %27 to i8*
store volatile i8* %1, i8** %27
%54 = bitcast i8** %28 to i8*
store volatile i8* %2, i8** %28
%55 = bitcast i8** %29 to i8*
store volatile i8* %3, i8** %29
%56 = bitcast i8** %30 to i8*
store volatile i8* %4, i8** %30
%57 = bitcast i8** %31 to i8*
store volatile i8* %5, i8** %31
%58 = bitcast i8** %32 to i8*
store volatile i8* %6, i8** %32
%59 = bitcast i8** %33 to i8*
store volatile i8* %21, i8** %33
%60 = bitcast i8** %34 to i8*
store volatile i8* %22, i8** %34
%61 = call i32 (...) @marker1()
ret i32 0
}