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;
  const char logical[2] = {laconic, laconic};
  const unsigned char lugged[2] = {laggard, laggard};
  const short luck[2] = {lagoon, lagoon};
  const unsigned short lunar[2] = {laity, laity};
  const long lumen[2] = {lambent, lambent};
  const unsigned long lurk[2] = {laminated, laminated};
  const float lush[2] = {lampoon, lampoon};
  const double lynx[2] = {languid, languid};
  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;
  volatile char violent[2] = {vox, vox};
  volatile unsigned char violet[2] = {victuals, victuals};
  volatile short vips[2] = {vixen, vixen};
  volatile unsigned short virgen[2] = {vitriol, vitriol};
  volatile long vulgar[2] = {vellum, vellum};
  volatile unsigned long vulture[2] = {valve, valve};
  volatile float vilify[2] = {vacuity, vacuity};
  volatile double villar[2] = {vertigo, 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;
  const volatile char vindictive[2] = {victor, victor};
  const volatile unsigned char vegetation[2] = {vicar, vicar};
  struct crass {
    char *const ptr;
  } crass = {lamprey};
  struct crisp {
    char *const *ptr;
  } crisp = {&lamprey};
  struct crass *creed = &crass;
  struct crisp *crow = &crisp;
  marker1();
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x370,%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  0xeda(%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  0xe94(%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)
mov    0xd3a(%rip),%ax
mov    %ax,-0x15a(%rbp)
mov    0xd2e(%rip),%ax
mov    %ax,-0x15c(%rbp)
mov    0xd17(%rip),%eax
mov    %eax,-0x160(%rbp)
mov    0xd0f(%rip),%eax
mov    %eax,-0x164(%rbp)
mov    0xd12(%rip),%rax
mov    %rax,-0x180(%rbp)
mov    0xd0c(%rip),%rax
mov    %rax,-0x178(%rbp)
mov    0xd06(%rip),%rax
mov    %rax,-0x190(%rbp)
mov    0xd00(%rip),%rax
mov    %rax,-0x188(%rbp)
mov    0xcb2(%rip),%rax
mov    %rax,-0x198(%rbp)
mov    0xcec(%rip),%rax
mov    %rax,-0x1b0(%rbp)
mov    0xce6(%rip),%rax
mov    %rax,-0x1a8(%rbp)
movb   $0x58,-0x1b1(%rbp)
movb   $0xd,-0x1b2(%rbp)
movw   $0xc8,-0x1b4(%rbp)
movw   $0x12c,-0x1b6(%rbp)
2c 01
movq   $0x3e8,-0x1c0(%rbp)
movq   $0x7d0,-0x1c8(%rbp)
movss  0xc59(%rip),%xmm0
movss  %xmm0,-0x1cc(%rbp)
ff
movsd  0xc29(%rip),%xmm0
movsd  %xmm0,-0x1d8(%rbp)
ff
lea    -0x1b1(%rbp),%rax
mov    %rax,-0x1e0(%rbp)
lea    -0x1b2(%rbp),%rax
mov    %rax,-0x1e8(%rbp)
lea    -0x1b4(%rbp),%rax
mov    %rax,-0x1f0(%rbp)
lea    -0x1b6(%rbp),%rax
mov    %rax,-0x1f8(%rbp)
lea    -0x1c0(%rbp),%rax
mov    %rax,-0x200(%rbp)
lea    -0x1c8(%rbp),%rax
mov    %rax,-0x208(%rbp)
lea    -0x1cc(%rbp),%rax
mov    %rax,-0x210(%rbp)
lea    -0x1d8(%rbp),%rax
mov    %rax,-0x218(%rbp)
lea    -0x1b1(%rbp),%rax
mov    %rax,-0x220(%rbp)
lea    -0x1b2(%rbp),%rax
mov    %rax,-0x228(%rbp)
lea    -0x1b4(%rbp),%rax
mov    %rax,-0x230(%rbp)
lea    -0x1b6(%rbp),%rax
mov    %rax,-0x238(%rbp)
lea    -0x1c0(%rbp),%rax
mov    %rax,-0x240(%rbp)
lea    -0x1c8(%rbp),%rax
mov    %rax,-0x248(%rbp)
lea    -0x1cc(%rbp),%rax
mov    %rax,-0x250(%rbp)
lea    -0x1d8(%rbp),%rax
mov    %rax,-0x258(%rbp)
mov    -0x1b1(%rbp),%al
mov    %al,-0x25a(%rbp)
mov    -0x1b1(%rbp),%al
mov    %al,-0x259(%rbp)
mov    -0x1b2(%rbp),%al
mov    %al,-0x25c(%rbp)
mov    -0x1b2(%rbp),%al
mov    %al,-0x25b(%rbp)
mov    -0x1b4(%rbp),%ax
mov    %ax,-0x260(%rbp)
mov    -0x1b4(%rbp),%ax
mov    %ax,-0x25e(%rbp)
mov    -0x1b6(%rbp),%ax
mov    %ax,-0x264(%rbp)
mov    -0x1b6(%rbp),%ax
mov    %ax,-0x262(%rbp)
mov    -0x1c0(%rbp),%rax
mov    %rax,-0x280(%rbp)
mov    -0x1c0(%rbp),%rax
mov    %rax,-0x278(%rbp)
mov    -0x1c8(%rbp),%rax
mov    %rax,-0x290(%rbp)
mov    -0x1c8(%rbp),%rax
mov    %rax,-0x288(%rbp)
movss  -0x1cc(%rbp),%xmm0
ff
movss  %xmm0,-0x298(%rbp)
ff
movss  -0x1cc(%rbp),%xmm0
ff
movss  %xmm0,-0x294(%rbp)
ff
movsd  -0x1d8(%rbp),%xmm0
ff
movsd  %xmm0,-0x2b0(%rbp)
ff
movsd  -0x1d8(%rbp),%xmm0
ff
movsd  %xmm0,-0x2a8(%rbp)
ff
movb   $0x59,-0x2b1(%rbp)
movb   $0xb,-0x2b2(%rbp)
lea    -0x2b1(%rbp),%rax
mov    %rax,-0x2c0(%rbp)
lea    -0x2b2(%rbp),%rax
mov    %rax,-0x2c8(%rbp)
lea    -0x1b1(%rbp),%rax
mov    %rax,-0x2d0(%rbp)
lea    -0x1b2(%rbp),%rax
mov    %rax,-0x2d8(%rbp)
lea    -0x2b1(%rbp),%rax
mov    %rax,-0x2e0(%rbp)
lea    -0x2b2(%rbp),%rax
mov    %rax,-0x2e8(%rbp)
lea    -0x32(%rbp),%rax
mov    %rax,-0x2f0(%rbp)
lea    -0x33(%rbp),%rax
mov    %rax,-0x2f8(%rbp)
lea    -0x2b1(%rbp),%rax
mov    %rax,-0x300(%rbp)
lea    -0x2b2(%rbp),%rax
mov    %rax,-0x308(%rbp)
lea    -0x5(%rbp),%rax
mov    %rax,-0x310(%rbp)
lea    -0x6(%rbp),%rax
mov    %rax,-0x318(%rbp)
lea    -0x32(%rbp),%rax
mov    %rax,-0x320(%rbp)
lea    -0x33(%rbp),%rax
mov    %rax,-0x328(%rbp)
lea    -0x1b1(%rbp),%rax
mov    %rax,-0x330(%rbp)
lea    -0x1b2(%rbp),%rax
mov    %rax,-0x338(%rbp)
lea    -0x2b1(%rbp),%rax
mov    %rax,-0x340(%rbp)
lea    -0x2b2(%rbp),%rax
mov    %rax,-0x348(%rbp)
mov    -0x2b1(%rbp),%al
mov    %al,-0x34a(%rbp)
mov    -0x2b1(%rbp),%al
mov    %al,-0x349(%rbp)
mov    -0x2b2(%rbp),%al
mov    %al,-0x34c(%rbp)
mov    -0x2b2(%rbp),%al
mov    %al,-0x34b(%rbp)
mov    -0x120(%rbp),%rax
mov    %rax,-0x358(%rbp)
lea    -0x120(%rbp),%rax
mov    %rax,-0x360(%rbp)
lea    -0x358(%rbp),%rax
mov    %rax,-0x368(%rbp)
lea    -0x360(%rbp),%rax
mov    %rax,-0x370(%rbp)
mov    $0x0,%al
call   1030 <marker1@plt>
xor    %eax,%eax
add    $0x370,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
sub    $0x128,%rsp
movb   $0x42,0xb(%rsp)
movb   $0xa,0xa(%rsp)
movb   $0x41,0x9(%rsp)
movb   $0x1,0x8(%rsp)
movb   $0x58,0x3(%rsp)
movb   $0xd,0x2(%rsp)
movw   $0xc8,0x6(%rsp)
movw   $0x12c,0x4(%rsp)
movq   $0x3e8,0x28(%rsp)
movq   $0x7d0,0x20(%rsp)
movl   $0x40400000,0xc(%rsp)
40
movabs $0x402499999999999a,%rax
99 24 40
mov    %rax,0x18(%rsp)
lea    0x3(%rsp),%r8
mov    %r8,0x120(%rsp)
lea    0x2(%rsp),%r9
mov    %r9,0x118(%rsp)
lea    0x6(%rsp),%rdx
mov    %rdx,0x110(%rsp)
lea    0x4(%rsp),%rdx
mov    %rdx,0x108(%rsp)
lea    0x28(%rsp),%rdx
mov    %rdx,0x100(%rsp)
lea    0x20(%rsp),%rdx
mov    %rdx,0xf8(%rsp)
lea    0xc(%rsp),%rdx
mov    %rdx,0xf0(%rsp)
lea    0x18(%rsp),%rdx
mov    %rdx,0xe8(%rsp)
mov    0x3(%rsp),%dl
mov    %dl,0x17(%rsp)
mov    0x3(%rsp),%dl
mov    %dl,0x16(%rsp)
mov    0x2(%rsp),%dl
mov    %dl,0x15(%rsp)
mov    0x2(%rsp),%dl
mov    %dl,0x14(%rsp)
movzwl 0x6(%rsp),%edx
mov    %dx,0x36(%rsp)
movzwl 0x6(%rsp),%edx
mov    %dx,0x34(%rsp)
movzwl 0x4(%rsp),%edx
mov    %dx,0x32(%rsp)
movzwl 0x4(%rsp),%edx
mov    %dx,0x30(%rsp)
mov    0x28(%rsp),%rdx
mov    %rdx,0x60(%rsp)
mov    0x28(%rsp),%rdx
mov    %rdx,0xe0(%rsp)
mov    0x20(%rsp),%rdx
mov    %rdx,0x50(%rsp)
mov    0x20(%rsp),%rdx
mov    %rdx,0xd8(%rsp)
movss  0xc(%rsp),%xmm0
movss  %xmm0,0x3c(%rsp)
movss  0xc(%rsp),%xmm0
movss  %xmm0,0x38(%rsp)
movsd  0x18(%rsp),%xmm0
movsd  %xmm0,0x40(%rsp)
movsd  0x18(%rsp),%xmm0
movsd  %xmm0,0xd0(%rsp)
movb   $0x59,0x1(%rsp)
movb   $0xb,(%rsp)
lea    0x9(%rsp),%rdx
mov    %rdx,0xc8(%rsp)
lea    0x8(%rsp),%rsi
mov    %rsi,0xc0(%rsp)
lea    0x1(%rsp),%rdi
mov    %rdi,0xb8(%rsp)
mov    %rsp,%rax
mov    %rax,0xb0(%rsp)
lea    0xb(%rsp),%rcx
mov    %rcx,0xa8(%rsp)
lea    0xa(%rsp),%rcx
mov    %rcx,0xa0(%rsp)
mov    %rdx,0x98(%rsp)
mov    %rsi,0x90(%rsp)
mov    %r8,0x88(%rsp)
mov    %r9,0x80(%rsp)
mov    %rdi,0x78(%rsp)
mov    %rax,0x70(%rsp)
mov    0x1(%rsp),%al
mov    %al,0x13(%rsp)
mov    0x1(%rsp),%al
mov    %al,0x12(%rsp)
mov    (%rsp),%al
mov    %al,0x11(%rsp)
mov    (%rsp),%al
mov    %al,0x10(%rsp)
xor    %eax,%eax
call   1030 <marker1@plt>
xor    %eax,%eax
add    $0x128,%rsp
ret

LLVM IR (-O0):
%struct.crass = type { i8* }
%struct.crisp = type { i8** }
@__const.main.logical = [2 x i8] c"AA"
@__const.main.lugged = [2 x i8] c"\01\01"
@__const.main.luck = [2 x i16] [i16 2, i16 2]
@__const.main.lunar = [2 x i16] [i16 3, i16 3]
@__const.main.lumen = [2 x i64] [i64 4, i64 4]
@__const.main.lurk = [2 x i64] [i64 5, i64 5]
@__const.main.lush = [2 x float] [float 6.000000e+00, float 6.000000e+00]
@__const.main.lynx = [2 x double] [double 7.000000e+00, double 7.000000e+00]
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 [2 x i8]
%52 = alloca [2 x i8]
%53 = alloca [2 x i16]
%54 = alloca [2 x i16]
%55 = alloca [2 x i64]
%56 = alloca [2 x i64]
%57 = alloca [2 x float]
%58 = alloca [2 x 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 i16*
%78 = alloca i16*
%79 = alloca i64*
%80 = alloca i64*
%81 = alloca float*
%82 = alloca double*
%83 = alloca [2 x i8]
%84 = alloca [2 x i8]
%85 = alloca [2 x i16]
%86 = alloca [2 x i16]
%87 = alloca [2 x i64]
%88 = alloca [2 x i64]
%89 = alloca [2 x float]
%90 = alloca [2 x double]
%91 = alloca i8
%92 = alloca i8
%93 = alloca i8*
%94 = alloca i8*
%95 = alloca i8*
%96 = alloca i8*
%97 = alloca i8*
%98 = alloca i8*
%99 = alloca i8*
%100 = alloca i8*
%101 = alloca i8*
%102 = alloca i8*
%103 = alloca i8*
%104 = alloca i8*
%105 = alloca i8*
%106 = alloca i8*
%107 = alloca i8*
%108 = alloca i8*
%109 = alloca i8*
%110 = alloca i8*
%111 = alloca [2 x i8]
%112 = alloca [2 x i8]
%113 = alloca %struct.crass
%114 = alloca %struct.crisp
%115 = alloca %struct.crass*
%116 = 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
%117 = bitcast [2 x i8]* %51 to i8*
%118 = bitcast [2 x i8]* %52 to i8*
%119 = bitcast [2 x i16]* %53 to i8*
%120 = bitcast [2 x i16]* %54 to i8*
%121 = bitcast [2 x i64]* %55 to i8*
%122 = bitcast [2 x i64]* %56 to i8*
%123 = bitcast [2 x float]* %57 to i8*
%124 = bitcast [2 x double]* %58 to i8*
store volatile i8 88, i8* %59
store volatile i8 13, i8* %60
store volatile i16 200, i16* %61
store volatile i16 300, i16* %62
store volatile i64 1000, i64* %63
store volatile i64 2000, i64* %64
store volatile float 3.000000e+00, float* %65
store volatile double 1.030000e+01, double* %66
store i8* %59, i8** %67
store i8* %60, i8** %68
store i16* %61, i16** %69
store i16* %62, i16** %70
store i64* %63, i64** %71
store i64* %64, i64** %72
store float* %65, float** %73
store double* %66, double** %74
store volatile i8* %59, i8** %75
store volatile i8* %60, i8** %76
store volatile i16* %61, i16** %77
store volatile i16* %62, i16** %78
store volatile i64* %63, i64** %79
store volatile i64* %64, i64** %80
store volatile float* %65, float** %81
store volatile double* %66, double** %82
%125 = getelementptr inbounds [2 x i8], [2 x i8]* %83, i64 0, i64 0
%126 = load volatile i8, i8* %59
store volatile i8 %126, i8* %125
%127 = getelementptr inbounds i8, i8* %125, i64 1
%128 = load volatile i8, i8* %59
store volatile i8 %128, i8* %127
%129 = getelementptr inbounds [2 x i8], [2 x i8]* %84, i64 0, i64 0
%130 = load volatile i8, i8* %60
store volatile i8 %130, i8* %129
%131 = getelementptr inbounds i8, i8* %129, i64 1
%132 = load volatile i8, i8* %60
store volatile i8 %132, i8* %131
%133 = getelementptr inbounds [2 x i16], [2 x i16]* %85, i64 0, i64 0
%134 = load volatile i16, i16* %61
store volatile i16 %134, i16* %133
%135 = getelementptr inbounds i16, i16* %133, i64 1
%136 = load volatile i16, i16* %61
store volatile i16 %136, i16* %135
%137 = getelementptr inbounds [2 x i16], [2 x i16]* %86, i64 0, i64 0
%138 = load volatile i16, i16* %62
store volatile i16 %138, i16* %137
%139 = getelementptr inbounds i16, i16* %137, i64 1
%140 = load volatile i16, i16* %62
store volatile i16 %140, i16* %139
%141 = getelementptr inbounds [2 x i64], [2 x i64]* %87, i64 0, i64 0
%142 = load volatile i64, i64* %63
store volatile i64 %142, i64* %141
%143 = getelementptr inbounds i64, i64* %141, i64 1
%144 = load volatile i64, i64* %63
store volatile i64 %144, i64* %143
%145 = getelementptr inbounds [2 x i64], [2 x i64]* %88, i64 0, i64 0
%146 = load volatile i64, i64* %64
store volatile i64 %146, i64* %145
%147 = getelementptr inbounds i64, i64* %145, i64 1
%148 = load volatile i64, i64* %64
store volatile i64 %148, i64* %147
%149 = getelementptr inbounds [2 x float], [2 x float]* %89, i64 0, i64 0
%150 = load volatile float, float* %65
store volatile float %150, float* %149
%151 = getelementptr inbounds float, float* %149, i64 1
%152 = load volatile float, float* %65
store volatile float %152, float* %151
%153 = getelementptr inbounds [2 x double], [2 x double]* %90, i64 0, i64 0
%154 = load volatile double, double* %66
store volatile double %154, double* %153
%155 = getelementptr inbounds double, double* %153, i64 1
%156 = load volatile double, double* %66
store volatile double %156, double* %155
store volatile i8 89, i8* %91
store volatile i8 11, i8* %92
store i8* %91, i8** %93
store i8* %92, i8** %94
store i8* %59, i8** %95
store i8* %60, i8** %96
store i8* %91, i8** %97
store i8* %92, i8** %98
store volatile i8* %11, i8** %99
store volatile i8* %12, i8** %100
store volatile i8* %91, i8** %101
store volatile i8* %92, i8** %102
store volatile i8* %2, i8** %103
store volatile i8* %3, i8** %104
store volatile i8* %11, i8** %105
store volatile i8* %12, i8** %106
store volatile i8* %59, i8** %107
store volatile i8* %60, i8** %108
store volatile i8* %91, i8** %109
store volatile i8* %92, i8** %110
%157 = getelementptr inbounds [2 x i8], [2 x i8]* %111, i64 0, i64 0
%158 = load volatile i8, i8* %91
store volatile i8 %158, i8* %157
%159 = getelementptr inbounds i8, i8* %157, i64 1
%160 = load volatile i8, i8* %91
store volatile i8 %160, i8* %159
%161 = getelementptr inbounds [2 x i8], [2 x i8]* %112, i64 0, i64 0
%162 = load volatile i8, i8* %92
store volatile i8 %162, i8* %161
%163 = getelementptr inbounds i8, i8* %161, i64 1
%164 = load volatile i8, i8* %92
store volatile i8 %164, i8* %163
%165 = getelementptr inbounds %struct.crass, %struct.crass* %113, i32 0, i32 0
%166 = load i8*, i8** %43
store i8* %166, i8** %165
%167 = getelementptr inbounds %struct.crisp, %struct.crisp* %114, i32 0, i32 0
store i8** %43, i8*** %167
store %struct.crass* %113, %struct.crass** %115
store %struct.crisp* %114, %struct.crisp** %116
%168 = call i32 (...) @marker1()
ret i32 0
}

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