void benchmark(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;
  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 = {lamprey};
  struct crisp {
    char *const *ptr;
  } crisp = {&lamprey};
  struct crass *creed = &crass;
  struct crisp *crow = &crisp;
  marker1();
}


x86 assembly (clang, -O0):
<benchmark>:
push   %rbp
mov    %rsp,%rbp
sub    $0x300,%rsp
movb   $0x42,-0x1(%rbp)
movb   $0xa,-0x2(%rbp)
movw   $0x14,-0x4(%rbp)
movw   $0x1e,-0x6(%rbp)
movq   $0x28,-0x10(%rbp)
movq   $0x32,-0x18(%rbp)
movss  0xee1(%rip),%xmm0
movss  %xmm0,-0x1c(%rbp)
movsd  0xebc(%rip),%xmm0
movsd  %xmm0,-0x28(%rbp)
movb   $0x23,-0x29(%rbp)
movb   $0x41,-0x2a(%rbp)
movb   $0x1,-0x2b(%rbp)
movw   $0x2,-0x2e(%rbp)
movw   $0x3,-0x30(%rbp)
movq   $0x4,-0x38(%rbp)
movq   $0x5,-0x40(%rbp)
movss  0xe9b(%rip),%xmm0
movss  %xmm0,-0x44(%rbp)
movsd  0xe72(%rip),%xmm0
movsd  %xmm0,-0x50(%rbp)
lea    -0x1(%rbp),%rax
mov    %rax,-0x58(%rbp)
lea    -0x2(%rbp),%rax
mov    %rax,-0x60(%rbp)
lea    -0x4(%rbp),%rax
mov    %rax,-0x68(%rbp)
lea    -0x6(%rbp),%rax
mov    %rax,-0x70(%rbp)
lea    -0x10(%rbp),%rax
mov    %rax,-0x78(%rbp)
lea    -0x18(%rbp),%rax
mov    %rax,-0x80(%rbp)
lea    -0x1c(%rbp),%rax
mov    %rax,-0x88(%rbp)
lea    -0x28(%rbp),%rax
mov    %rax,-0x90(%rbp)
lea    -0x2a(%rbp),%rax
mov    %rax,-0x98(%rbp)
lea    -0x2b(%rbp),%rax
mov    %rax,-0xa0(%rbp)
lea    -0x2e(%rbp),%rax
mov    %rax,-0xa8(%rbp)
lea    -0x30(%rbp),%rax
mov    %rax,-0xb0(%rbp)
lea    -0x38(%rbp),%rax
mov    %rax,-0xb8(%rbp)
lea    -0x40(%rbp),%rax
mov    %rax,-0xc0(%rbp)
lea    -0x44(%rbp),%rax
mov    %rax,-0xc8(%rbp)
lea    -0x50(%rbp),%rax
mov    %rax,-0xd0(%rbp)
lea    -0x2a(%rbp),%rax
mov    %rax,-0xd8(%rbp)
lea    -0x2b(%rbp),%rax
mov    %rax,-0xe0(%rbp)
lea    -0x2e(%rbp),%rax
mov    %rax,-0xe8(%rbp)
lea    -0x30(%rbp),%rax
mov    %rax,-0xf0(%rbp)
lea    -0x38(%rbp),%rax
mov    %rax,-0xf8(%rbp)
lea    -0x40(%rbp),%rax
mov    %rax,-0x100(%rbp)
lea    -0x44(%rbp),%rax
mov    %rax,-0x108(%rbp)
lea    -0x50(%rbp),%rax
mov    %rax,-0x110(%rbp)
lea    -0x1(%rbp),%rax
mov    %rax,-0x118(%rbp)
lea    -0x2(%rbp),%rax
mov    %rax,-0x120(%rbp)
lea    -0x4(%rbp),%rax
mov    %rax,-0x128(%rbp)
lea    -0x6(%rbp),%rax
mov    %rax,-0x130(%rbp)
lea    -0x10(%rbp),%rax
mov    %rax,-0x138(%rbp)
lea    -0x18(%rbp),%rax
mov    %rax,-0x140(%rbp)
lea    -0x1c(%rbp),%rax
mov    %rax,-0x148(%rbp)
lea    -0x28(%rbp),%rax
mov    %rax,-0x150(%rbp)
mov    0xd44(%rip),%ax
mov    %ax,-0x152(%rbp)
mov    0xd38(%rip),%ax
mov    %ax,-0x154(%rbp)
mov    0xd21(%rip),%eax
mov    %eax,-0x158(%rbp)
mov    0xd19(%rip),%eax
mov    %eax,-0x15c(%rbp)
mov    0xd1c(%rip),%rax
mov    %rax,-0x170(%rbp)
mov    0xd16(%rip),%rax
mov    %rax,-0x168(%rbp)
mov    0xd10(%rip),%rax
mov    %rax,-0x180(%rbp)
mov    0xd0a(%rip),%rax
mov    %rax,-0x178(%rbp)
mov    0xcbc(%rip),%rax
mov    %rax,-0x188(%rbp)
mov    0xcf6(%rip),%rax
mov    %rax,-0x1a0(%rbp)
mov    0xcf0(%rip),%rax
mov    %rax,-0x198(%rbp)
movb   $0x58,-0x1a1(%rbp)
movb   $0xd,-0x1a2(%rbp)
movw   $0xc8,-0x1a4(%rbp)
movw   $0x12c,-0x1a6(%rbp)
2c 01
movq   $0x3e8,-0x1b0(%rbp)
movq   $0x7d0,-0x1b8(%rbp)
movss  0xc63(%rip),%xmm0
movss  %xmm0,-0x1bc(%rbp)
ff
movsd  0xc33(%rip),%xmm0
movsd  %xmm0,-0x1c8(%rbp)
ff
lea    -0x1a1(%rbp),%rax
mov    %rax,-0x1d0(%rbp)
lea    -0x1a2(%rbp),%rax
mov    %rax,-0x1d8(%rbp)
lea    -0x1a4(%rbp),%rax
mov    %rax,-0x1e0(%rbp)
lea    -0x1a6(%rbp),%rax
mov    %rax,-0x1e8(%rbp)
lea    -0x1b0(%rbp),%rax
mov    %rax,-0x1f0(%rbp)
lea    -0x1b8(%rbp),%rax
mov    %rax,-0x1f8(%rbp)
lea    -0x1bc(%rbp),%rax
mov    %rax,-0x200(%rbp)
lea    -0x1c8(%rbp),%rax
mov    %rax,-0x208(%rbp)
lea    -0x1a1(%rbp),%rax
mov    %rax,-0x210(%rbp)
lea    -0x1a2(%rbp),%rax
mov    %rax,-0x218(%rbp)
lea    -0x1a4(%rbp),%rax
mov    %rax,-0x220(%rbp)
lea    -0x1a6(%rbp),%rax
mov    %rax,-0x228(%rbp)
lea    -0x1b0(%rbp),%rax
mov    %rax,-0x230(%rbp)
lea    -0x1b8(%rbp),%rax
mov    %rax,-0x238(%rbp)
lea    -0x1bc(%rbp),%rax
mov    %rax,-0x240(%rbp)
lea    -0x1c8(%rbp),%rax
mov    %rax,-0x248(%rbp)
movb   $0x59,-0x249(%rbp)
movb   $0xb,-0x24a(%rbp)
lea    -0x249(%rbp),%rax
mov    %rax,-0x258(%rbp)
lea    -0x24a(%rbp),%rax
mov    %rax,-0x260(%rbp)
lea    -0x1a1(%rbp),%rax
mov    %rax,-0x268(%rbp)
lea    -0x1a2(%rbp),%rax
mov    %rax,-0x270(%rbp)
lea    -0x249(%rbp),%rax
mov    %rax,-0x278(%rbp)
lea    -0x24a(%rbp),%rax
mov    %rax,-0x280(%rbp)
lea    -0x2a(%rbp),%rax
mov    %rax,-0x288(%rbp)
lea    -0x2b(%rbp),%rax
mov    %rax,-0x290(%rbp)
lea    -0x249(%rbp),%rax
mov    %rax,-0x298(%rbp)
lea    -0x24a(%rbp),%rax
mov    %rax,-0x2a0(%rbp)
lea    -0x1(%rbp),%rax
mov    %rax,-0x2a8(%rbp)
lea    -0x2(%rbp),%rax
mov    %rax,-0x2b0(%rbp)
lea    -0x2a(%rbp),%rax
mov    %rax,-0x2b8(%rbp)
lea    -0x2b(%rbp),%rax
mov    %rax,-0x2c0(%rbp)
lea    -0x1a1(%rbp),%rax
mov    %rax,-0x2c8(%rbp)
lea    -0x1a2(%rbp),%rax
mov    %rax,-0x2d0(%rbp)
lea    -0x249(%rbp),%rax
mov    %rax,-0x2d8(%rbp)
lea    -0x24a(%rbp),%rax
mov    %rax,-0x2e0(%rbp)
mov    -0x118(%rbp),%rax
mov    %rax,-0x2e8(%rbp)
lea    -0x118(%rbp),%rax
mov    %rax,-0x2f0(%rbp)
lea    -0x2e8(%rbp),%rax
mov    %rax,-0x2f8(%rbp)
lea    -0x2f0(%rbp),%rax
mov    %rax,-0x300(%rbp)
mov    $0x0,%al
call   1030 <marker1@plt>
add    $0x300,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<benchmark>:
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>
add    $0xc8,%rsp
ret

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

LLVM IR (-O2):
%struct.crass = type { i8* }
%struct.crisp = type { i8** }
define void @benchmark() {
%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 void
}