#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 /*<<< orphan*/ abort();
int /*<<< orphan*/ fbar(float *);
int /*<<< orphan*/ ibar(int *);
int /*<<< orphan*/ sbar(short *);
int foo(int n) {
  int i, j;
  float a[16];
  float e[16];
  float b[16] = {0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45};
  float c[16] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
  float d[16] = {0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30};
  short sc[16] = {0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45};
  short sb[16] = {0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45};
  short sa[16];
  int ic[16] = {0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45};
  int ib[16] = {0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45};
  int ia[16];
  int diff = 0;
  char cb[16];
  char cc[16];
  char image[16][16];
  char block[16][16];
  for (i = 0; i < 16; i++) {
    ia[i] = (int)sb[i];
  }
  fbar(a);
  for (i = 0; i < 16 / 2; i++) {
    a[i] = b[2 * i + 1] * c[2 * i + 1] - b[2 * i] * c[2 * i];
    d[i] = b[2 * i] * c[2 * i + 1] + b[2 * i + 1] * c[2 * i];
  }
  fbar(a);
  for (i = 0; i < 16; i++) {
    ia[i] = ib[i] * ic[i];
  }
  ibar(ia);
  for (i = 0; i < 16; i++) {
    ia[i] = ib[i] + ic[i];
    sa[i] = sb[i] + sc[i];
  }
  ibar(ia);
  sbar(sa);
  for (i = 0; i < 16; i++) {
    a[i] = b[i] + c[i];
    a[i + 1] = b[i] + c[i];
  }
  fbar(a);
  for (i = 0; i < 16; i++) {
    a[i] = (b[i] > 0 ? b[i] : 0);
  }
  fbar(a);
  diff = 0;
  for (i = 0; i < 16; i++) {
    diff += (cb[i] - cc[i]);
  }
  ibar(&diff);
  diff = 0;
  for (i = 0; i < 16; i++) {
    for (i = 0; i < 16; i++) {
      diff += (image[i][j] - block[i][j]);
    }
  }
  ibar(&diff);
  for (i = 0; i < 16; i++) {
    a[i] = i;
  }
  fbar(a);
  for (i = 16; i > 0; i--) {
    a[16 - i] = b[i - 1];
  }
  for (i = 0; i < 16; i++) {
    if (a[i] != b[16 - 1 - i])
      abort();
  }
  return 0;
}


x86 assembly (clang, -O0):
<foo>:
push   %rbp
mov    %rsp,%rbp
sub    $0x4b0,%rsp
mov    %edi,-0x4(%rbp)
lea    -0xd0(%rbp),%rdi
lea    0xe94(%rip),%rsi
mov    $0x40,%edx
call   1050 <memcpy@plt>
lea    -0x110(%rbp),%rdi
lea    0xebc(%rip),%rsi
mov    $0x40,%edx
call   1050 <memcpy@plt>
lea    -0x150(%rbp),%rdi
lea    0xee4(%rip),%rsi
mov    $0x40,%edx
call   1050 <memcpy@plt>
mov    0xf93(%rip),%rax
mov    %rax,-0x170(%rbp)
mov    0xf8d(%rip),%rax
mov    %rax,-0x168(%rbp)
mov    0xf87(%rip),%rax
mov    %rax,-0x160(%rbp)
mov    0xf81(%rip),%rax
mov    %rax,-0x158(%rbp)
mov    0xf5b(%rip),%rax
mov    %rax,-0x190(%rbp)
mov    0xf55(%rip),%rax
mov    %rax,-0x188(%rbp)
mov    0xf4f(%rip),%rax
mov    %rax,-0x180(%rbp)
mov    0xf49(%rip),%rax
mov    %rax,-0x178(%rbp)
lea    -0x1f0(%rbp),%rdi
lea    0xe9c(%rip),%rsi
mov    $0x40,%edx
call   1050 <memcpy@plt>
lea    -0x230(%rbp),%rdi
lea    0xec4(%rip),%rsi
mov    $0x40,%edx
call   1050 <memcpy@plt>
movl   $0x0,-0x274(%rbp)
movl   $0x0,-0x8(%rbp)
cmpl   $0x10,-0x8(%rbp)
jge    1286 <foo+0x136>
movslq -0x8(%rbp),%rax
movswl -0x190(%rbp,%rax,2),%ecx
ff
movslq -0x8(%rbp),%rax
mov    %ecx,-0x270(%rbp,%rax,4)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1257 <foo+0x107>
lea    -0x50(%rbp),%rdi
call   1060 <fbar@plt>
movl   $0x0,-0x8(%rbp)
cmpl   $0x8,-0x8(%rbp)
jge    1376 <foo+0x226>
mov    -0x8(%rbp),%eax
shl    $0x1,%eax
add    $0x1,%eax
cltq
movss  -0xd0(%rbp,%rax,4),%xmm0
ff ff
mov    -0x8(%rbp),%eax
shl    $0x1,%eax
add    $0x1,%eax
cltq
movss  -0x110(%rbp,%rax,4),%xmm2
ff ff
mov    -0x8(%rbp),%eax
shl    $0x1,%eax
cltq
movss  -0xd0(%rbp,%rax,4),%xmm1
ff ff
mov    -0x8(%rbp),%eax
shl    $0x1,%eax
cltq
mulss  -0x110(%rbp,%rax,4),%xmm1
ff ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq -0x8(%rbp),%rax
movss  %xmm0,-0x50(%rbp,%rax,4)
mov    -0x8(%rbp),%eax
shl    $0x1,%eax
cltq
movss  -0xd0(%rbp,%rax,4),%xmm0
ff ff
mov    -0x8(%rbp),%eax
shl    $0x1,%eax
add    $0x1,%eax
cltq
movss  -0x110(%rbp,%rax,4),%xmm2
ff ff
mov    -0x8(%rbp),%eax
shl    $0x1,%eax
add    $0x1,%eax
cltq
movss  -0xd0(%rbp,%rax,4),%xmm1
ff ff
mov    -0x8(%rbp),%eax
shl    $0x1,%eax
cltq
mulss  -0x110(%rbp,%rax,4),%xmm1
ff ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq -0x8(%rbp),%rax
movss  %xmm0,-0x150(%rbp,%rax,4)
ff ff
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1296 <foo+0x146>
lea    -0x50(%rbp),%rdi
call   1060 <fbar@plt>
movl   $0x0,-0x8(%rbp)
cmpl   $0x10,-0x8(%rbp)
jge    13c0 <foo+0x270>
movslq -0x8(%rbp),%rax
mov    -0x230(%rbp,%rax,4),%ecx
movslq -0x8(%rbp),%rax
imul   -0x1f0(%rbp,%rax,4),%ecx
ff
movslq -0x8(%rbp),%rax
mov    %ecx,-0x270(%rbp,%rax,4)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1386 <foo+0x236>
lea    -0x270(%rbp),%rdi
call   1070 <ibar@plt>
movl   $0x0,-0x8(%rbp)
cmpl   $0x10,-0x8(%rbp)
jge    1435 <foo+0x2e5>
movslq -0x8(%rbp),%rax
mov    -0x230(%rbp,%rax,4),%ecx
movslq -0x8(%rbp),%rax
add    -0x1f0(%rbp,%rax,4),%ecx
movslq -0x8(%rbp),%rax
mov    %ecx,-0x270(%rbp,%rax,4)
movslq -0x8(%rbp),%rax
movswl -0x190(%rbp,%rax,2),%eax
ff
movslq -0x8(%rbp),%rcx
movswl -0x170(%rbp,%rcx,2),%ecx
ff
add    %ecx,%eax
mov    %ax,%cx
movslq -0x8(%rbp),%rax
mov    %cx,-0x1b0(%rbp,%rax,2)
ff
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    13d3 <foo+0x283>
lea    -0x270(%rbp),%rdi
call   1070 <ibar@plt>
lea    -0x1b0(%rbp),%rdi
call   1030 <sbar@plt>
movl   $0x0,-0x8(%rbp)
cmpl   $0x10,-0x8(%rbp)
jge    14b8 <foo+0x368>
movslq -0x8(%rbp),%rax
movss  -0xd0(%rbp,%rax,4),%xmm0
ff ff
movslq -0x8(%rbp),%rax
addss  -0x110(%rbp,%rax,4),%xmm0
ff ff
movslq -0x8(%rbp),%rax
movss  %xmm0,-0x50(%rbp,%rax,4)
movslq -0x8(%rbp),%rax
movss  -0xd0(%rbp,%rax,4),%xmm0
ff ff
movslq -0x8(%rbp),%rax
addss  -0x110(%rbp,%rax,4),%xmm0
ff ff
mov    -0x8(%rbp),%eax
add    $0x1,%eax
cltq
movss  %xmm0,-0x50(%rbp,%rax,4)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1454 <foo+0x304>
lea    -0x50(%rbp),%rdi
call   1060 <fbar@plt>
movl   $0x0,-0x8(%rbp)
cmpl   $0x10,-0x8(%rbp)
jge    1535 <foo+0x3e5>
movslq -0x8(%rbp),%rax
movss  -0xd0(%rbp,%rax,4),%xmm0
ff ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    1505 <foo+0x3b5>
movslq -0x8(%rbp),%rax
movss  -0xd0(%rbp,%rax,4),%xmm0
ff ff
movss  %xmm0,-0x4a4(%rbp)
ff
jmp    1515 <foo+0x3c5>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x4a4(%rbp)
ff
jmp    1515 <foo+0x3c5>
movss  -0x4a4(%rbp),%xmm0
ff
movslq -0x8(%rbp),%rax
movss  %xmm0,-0x50(%rbp,%rax,4)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    14c8 <foo+0x378>
lea    -0x50(%rbp),%rdi
call   1060 <fbar@plt>
movl   $0x0,-0x274(%rbp)
movl   $0x0,-0x8(%rbp)
cmpl   $0x10,-0x8(%rbp)
jge    158d <foo+0x43d>
movslq -0x8(%rbp),%rax
movsbl -0x290(%rbp,%rax,1),%eax
ff
movslq -0x8(%rbp),%rcx
movsbl -0x2a0(%rbp,%rcx,1),%ecx
ff
sub    %ecx,%eax
add    -0x274(%rbp),%eax
mov    %eax,-0x274(%rbp)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    154f <foo+0x3ff>
lea    -0x274(%rbp),%rdi
call   1070 <ibar@plt>
movl   $0x0,-0x274(%rbp)
movl   $0x0,-0x8(%rbp)
cmpl   $0x10,-0x8(%rbp)
jge    1628 <foo+0x4d8>
movl   $0x0,-0x8(%rbp)
cmpl   $0x10,-0x8(%rbp)
jge    1615 <foo+0x4c5>
movslq -0x8(%rbp),%rcx
lea    -0x3a0(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0xc(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
movslq -0x8(%rbp),%rdx
lea    -0x4a0(%rbp),%rcx
shl    $0x4,%rdx
add    %rdx,%rcx
movslq -0xc(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
sub    %ecx,%eax
add    -0x274(%rbp),%eax
mov    %eax,-0x274(%rbp)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    15bb <foo+0x46b>
jmp    161a <foo+0x4ca>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    15aa <foo+0x45a>
lea    -0x274(%rbp),%rdi
call   1070 <ibar@plt>
movl   $0x0,-0x8(%rbp)
cmpl   $0x10,-0x8(%rbp)
jge    1662 <foo+0x512>
cvtsi2ssl -0x8(%rbp),%xmm0
movslq -0x8(%rbp),%rax
movss  %xmm0,-0x50(%rbp,%rax,4)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    163b <foo+0x4eb>
lea    -0x50(%rbp),%rdi
call   1060 <fbar@plt>
movl   $0x10,-0x8(%rbp)
cmpl   $0x0,-0x8(%rbp)
jle    16ab <foo+0x55b>
mov    -0x8(%rbp),%eax
sub    $0x1,%eax
cltq
movss  -0xd0(%rbp,%rax,4),%xmm0
ff ff
mov    $0x10,%eax
sub    -0x8(%rbp),%eax
cltq
movss  %xmm0,-0x50(%rbp,%rax,4)
mov    -0x8(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x8(%rbp)
jmp    1672 <foo+0x522>
movl   $0x0,-0x8(%rbp)
cmpl   $0x10,-0x8(%rbp)
jge    1703 <foo+0x5b3>
movslq -0x8(%rbp),%rax
movss  -0x50(%rbp,%rax,4),%xmm0
mov    $0xf,%eax
sub    -0x8(%rbp),%eax
cltq
ucomiss -0xd0(%rbp,%rax,4),%xmm0
ff
jne    16e9 <foo+0x599>
jp     16e9 <foo+0x599>
jmp    16f0 <foo+0x5a0>
mov    $0x0,%al
call   1040 <abort@plt>
jmp    16f5 <foo+0x5a5>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    16b2 <foo+0x562>
xor    %eax,%eax
add    $0x4b0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<foo>:
push   %r14
push   %rbx
sub    $0xb8,%rsp
movl   $0x0,0xc(%rsp)
lea    0x10(%rsp),%rbx
mov    %rbx,%rdi
call   1040 <fbar@plt>
movaps 0xeaa(%rip),%xmm0
movaps %xmm0,0x10(%rsp)
movaps 0xeae(%rip),%xmm0
movaps %xmm0,0x20(%rsp)
mov    %rbx,%rdi
call   1040 <fbar@plt>
movaps 0xeaa(%rip),%xmm0
movaps %xmm0,0x50(%rsp)
movaps 0xeae(%rip),%xmm0
movaps %xmm0,0x60(%rsp)
movaps 0xeb2(%rip),%xmm0
movaps %xmm0,0x70(%rsp)
movaps 0xeb6(%rip),%xmm0
movaps %xmm0,0x80(%rsp)
lea    0x50(%rsp),%rbx
mov    %rbx,%rdi
call   1050 <ibar@plt>
movaps 0xeaa(%rip),%xmm0
movaps %xmm0,0x50(%rsp)
movaps 0xeae(%rip),%xmm0
movaps %xmm0,0x90(%rsp)
movaps 0xeaf(%rip),%xmm0
movaps %xmm0,0x60(%rsp)
movaps 0xeb3(%rip),%xmm0
movaps %xmm0,0x70(%rsp)
movaps 0xeb7(%rip),%xmm0
movaps %xmm0,0xa0(%rsp)
movaps 0xeb8(%rip),%xmm0
movaps %xmm0,0x80(%rsp)
mov    %rbx,%rdi
call   1050 <ibar@plt>
lea    0x90(%rsp),%rdi
call   1030 <sbar@plt>
xor    %eax,%eax
lea    0xf22(%rip),%rcx
lea    0xf5b(%rip),%rdx
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%rcx,%rax,4),%xmm0
addss  (%rdx,%rax,4),%xmm0
movss  0x4(%rcx,%rax,4),%xmm1
movss  %xmm0,0x10(%rsp,%rax,4)
addss  0x4(%rdx,%rax,4),%xmm1
movss  %xmm1,0x14(%rsp,%rax,4)
movss  %xmm1,0x18(%rsp,%rax,4)
add    $0x2,%rax
cmp    $0x10,%rax
jne    1230 <foo+0x100>
lea    0x10(%rsp),%r14
mov    %r14,%rdi
call   1040 <fbar@plt>
movaps 0xe4a(%rip),%xmm0
movaps %xmm0,0x10(%rsp)
movaps 0xe4e(%rip),%xmm0
movaps %xmm0,0x20(%rsp)
movaps 0xe52(%rip),%xmm0
movaps %xmm0,0x30(%rsp)
movaps 0xe56(%rip),%xmm0
movaps %xmm0,0x40(%rsp)
mov    %r14,%rdi
call   1040 <fbar@plt>
movl   $0x0,0xc(%rsp)
lea    0xc(%rsp),%rbx
mov    %rbx,%rdi
call   1050 <ibar@plt>
movl   $0x0,0xc(%rsp)
mov    %rbx,%rdi
call   1050 <ibar@plt>
movaps 0xe2d(%rip),%xmm0
movaps %xmm0,0x10(%rsp)
movaps 0xe31(%rip),%xmm0
movaps %xmm0,0x20(%rsp)
movaps 0xe35(%rip),%xmm0
movaps %xmm0,0x30(%rsp)
movaps 0xe39(%rip),%xmm0
movaps %xmm0,0x40(%rsp)
mov    %r14,%rdi
call   1040 <fbar@plt>
xor    %eax,%eax
add    $0xb8,%rsp
pop    %rbx
pop    %r14
ret

LLVM IR (-O0):
@__const.foo.b = [16 x float] [float 0.000000e+00, float 3.000000e+00, float 6.000000e+00, float 9.000000e+00, float 1.200000e+01, float 1.500000e+01, float 1.800000e+01, float 2.100000e+01, float 2.400000e+01, float 2.700000e+01, float 3.000000e+01, float 3.300000e+01, float 3.600000e+01, float 3.900000e+01, float 4.200000e+01, float 4.500000e+01]
@__const.foo.c = [16 x float] [float 0.000000e+00, float 1.000000e+00, float 2.000000e+00, float 3.000000e+00, float 4.000000e+00, float 5.000000e+00, float 6.000000e+00, float 7.000000e+00, float 8.000000e+00, float 9.000000e+00, float 1.000000e+01, float 1.100000e+01, float 1.200000e+01, float 1.300000e+01, float 1.400000e+01, float 1.500000e+01]
@__const.foo.d = [16 x float] [float 0.000000e+00, float 2.000000e+00, float 4.000000e+00, float 6.000000e+00, float 8.000000e+00, float 1.000000e+01, float 1.200000e+01, float 1.400000e+01, float 1.600000e+01, float 1.800000e+01, float 2.000000e+01, float 2.200000e+01, float 2.400000e+01, float 2.600000e+01, float 2.800000e+01, float 3.000000e+01]
@__const.foo.sc = [16 x i16] [i16 0, i16 3, i16 6, i16 9, i16 12, i16 15, i16 18, i16 21, i16 24, i16 27, i16 30, i16 33, i16 36, i16 39, i16 42, i16 45]
@__const.foo.sb = [16 x i16] [i16 0, i16 3, i16 6, i16 9, i16 12, i16 15, i16 18, i16 21, i16 24, i16 27, i16 30, i16 33, i16 36, i16 39, i16 42, i16 45]
@__const.foo.ic = [16 x i32] [i32 0, i32 3, i32 6, i32 9, i32 12, i32 15, i32 18, i32 21, i32 24, i32 27, i32 30, i32 33, i32 36, i32 39, i32 42, i32 45]
@__const.foo.ib = [16 x i32] [i32 0, i32 3, i32 6, i32 9, i32 12, i32 15, i32 18, i32 21, i32 24, i32 27, i32 30, i32 33, i32 36, i32 39, i32 42, i32 45]
define i32 @foo(i32 %0) {
%2 = alloca i32
%3 = alloca i32
%4 = alloca i32
%5 = alloca [16 x float]
%6 = alloca [16 x float]
%7 = alloca [16 x float]
%8 = alloca [16 x float]
%9 = alloca [16 x float]
%10 = alloca [16 x i16]
%11 = alloca [16 x i16]
%12 = alloca [16 x i16]
%13 = alloca [16 x i32]
%14 = alloca [16 x i32]
%15 = alloca [16 x i32]
%16 = alloca i32
%17 = alloca [16 x i8]
%18 = alloca [16 x i8]
%19 = alloca [16 x [16 x i8]]
%20 = alloca [16 x [16 x i8]]
store i32 %0, i32* %2
%21 = bitcast [16 x float]* %7 to i8*
%22 = bitcast [16 x float]* %8 to i8*
%23 = bitcast [16 x float]* %9 to i8*
%24 = bitcast [16 x i16]* %10 to i8*
%25 = bitcast [16 x i16]* %11 to i8*
%26 = bitcast [16 x i32]* %13 to i8*
%27 = bitcast [16 x i32]* %14 to i8*
store i32 0, i32* %16
store i32 0, i32* %3
br label %28
28: ; preds = %40, %1
%29 = load i32, i32* %3
%30 = icmp slt i32 %29, 16
br i1 %30, label %31, label %43
31: ; preds = %28
%32 = load i32, i32* %3
%33 = sext i32 %32 to i64
%34 = getelementptr inbounds [16 x i16], [16 x i16]* %11, i64 0, i64 %33
%35 = load i16, i16* %34
%36 = sext i16 %35 to i32
%37 = load i32, i32* %3
%38 = sext i32 %37 to i64
%39 = getelementptr inbounds [16 x i32], [16 x i32]* %15, i64 0, i64 %38
store i32 %36, i32* %39
br label %40
40: ; preds = %31
%41 = load i32, i32* %3
%42 = add nsw i32 %41, 1
store i32 %42, i32* %3
br label %28
43: ; preds = %28
%44 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 0
%45 = call i32 @fbar(float* %44)
store i32 0, i32* %3
br label %46
46: ; preds = %105, %43
%47 = load i32, i32* %3
%48 = icmp slt i32 %47, 8
br i1 %48, label %49, label %108
49: ; preds = %46
%50 = load i32, i32* %3
%51 = mul nsw i32 2, %50
%52 = add nsw i32 %51, 1
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds [16 x float], [16 x float]* %7, i64 0, i64 %53
%55 = load float, float* %54
%56 = load i32, i32* %3
%57 = mul nsw i32 2, %56
%58 = add nsw i32 %57, 1
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds [16 x float], [16 x float]* %8, i64 0, i64 %59
%61 = load float, float* %60
%62 = load i32, i32* %3
%63 = mul nsw i32 2, %62
%64 = sext i32 %63 to i64
%65 = getelementptr inbounds [16 x float], [16 x float]* %7, i64 0, i64 %64
%66 = load float, float* %65
%67 = load i32, i32* %3
%68 = mul nsw i32 2, %67
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds [16 x float], [16 x float]* %8, i64 0, i64 %69
%71 = load float, float* %70
%72 = fmul float %66, %71
%73 = fneg float %72
%74 = call float @llvm.fmuladd.f32(float %55, float %61, float %73)
%75 = load i32, i32* %3
%76 = sext i32 %75 to i64
%77 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 %76
store float %74, float* %77
%78 = load i32, i32* %3
%79 = mul nsw i32 2, %78
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds [16 x float], [16 x float]* %7, i64 0, i64 %80
%82 = load float, float* %81
%83 = load i32, i32* %3
%84 = mul nsw i32 2, %83
%85 = add nsw i32 %84, 1
%86 = sext i32 %85 to i64
%87 = getelementptr inbounds [16 x float], [16 x float]* %8, i64 0, i64 %86
%88 = load float, float* %87
%89 = load i32, i32* %3
%90 = mul nsw i32 2, %89
%91 = add nsw i32 %90, 1
%92 = sext i32 %91 to i64
%93 = getelementptr inbounds [16 x float], [16 x float]* %7, i64 0, i64 %92
%94 = load float, float* %93
%95 = load i32, i32* %3
%96 = mul nsw i32 2, %95
%97 = sext i32 %96 to i64
%98 = getelementptr inbounds [16 x float], [16 x float]* %8, i64 0, i64 %97
%99 = load float, float* %98
%100 = fmul float %94, %99
%101 = call float @llvm.fmuladd.f32(float %82, float %88, float %100)
%102 = load i32, i32* %3
%103 = sext i32 %102 to i64
%104 = getelementptr inbounds [16 x float], [16 x float]* %9, i64 0, i64 %103
store float %101, float* %104
br label %105
105: ; preds = %49
%106 = load i32, i32* %3
%107 = add nsw i32 %106, 1
store i32 %107, i32* %3
br label %46
108: ; preds = %46
%109 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 0
%110 = call i32 @fbar(float* %109)
store i32 0, i32* %3
br label %111
111: ; preds = %127, %108
%112 = load i32, i32* %3
%113 = icmp slt i32 %112, 16
br i1 %113, label %114, label %130
114: ; preds = %111
%115 = load i32, i32* %3
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds [16 x i32], [16 x i32]* %14, i64 0, i64 %116
%118 = load i32, i32* %117
%119 = load i32, i32* %3
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds [16 x i32], [16 x i32]* %13, i64 0, i64 %120
%122 = load i32, i32* %121
%123 = mul nsw i32 %118, %122
%124 = load i32, i32* %3
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds [16 x i32], [16 x i32]* %15, i64 0, i64 %125
store i32 %123, i32* %126
br label %127
127: ; preds = %114
%128 = load i32, i32* %3
%129 = add nsw i32 %128, 1
store i32 %129, i32* %3
br label %111
130: ; preds = %111
%131 = getelementptr inbounds [16 x i32], [16 x i32]* %15, i64 0, i64 0
%132 = call i32 @ibar(i32* %131)
store i32 0, i32* %3
br label %133
133: ; preds = %164, %130
%134 = load i32, i32* %3
%135 = icmp slt i32 %134, 16
br i1 %135, label %136, label %167
136: ; preds = %133
%137 = load i32, i32* %3
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds [16 x i32], [16 x i32]* %14, i64 0, i64 %138
%140 = load i32, i32* %139
%141 = load i32, i32* %3
%142 = sext i32 %141 to i64
%143 = getelementptr inbounds [16 x i32], [16 x i32]* %13, i64 0, i64 %142
%144 = load i32, i32* %143
%145 = add nsw i32 %140, %144
%146 = load i32, i32* %3
%147 = sext i32 %146 to i64
%148 = getelementptr inbounds [16 x i32], [16 x i32]* %15, i64 0, i64 %147
store i32 %145, i32* %148
%149 = load i32, i32* %3
%150 = sext i32 %149 to i64
%151 = getelementptr inbounds [16 x i16], [16 x i16]* %11, i64 0, i64 %150
%152 = load i16, i16* %151
%153 = sext i16 %152 to i32
%154 = load i32, i32* %3
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds [16 x i16], [16 x i16]* %10, i64 0, i64 %155
%157 = load i16, i16* %156
%158 = sext i16 %157 to i32
%159 = add nsw i32 %153, %158
%160 = trunc i32 %159 to i16
%161 = load i32, i32* %3
%162 = sext i32 %161 to i64
%163 = getelementptr inbounds [16 x i16], [16 x i16]* %12, i64 0, i64 %162
store i16 %160, i16* %163
br label %164
164: ; preds = %136
%165 = load i32, i32* %3
%166 = add nsw i32 %165, 1
store i32 %166, i32* %3
br label %133
167: ; preds = %133
%168 = getelementptr inbounds [16 x i32], [16 x i32]* %15, i64 0, i64 0
%169 = call i32 @ibar(i32* %168)
%170 = getelementptr inbounds [16 x i16], [16 x i16]* %12, i64 0, i64 0
%171 = call i32 @sbar(i16* %170)
store i32 0, i32* %3
br label %172
172: ; preds = %201, %167
%173 = load i32, i32* %3
%174 = icmp slt i32 %173, 16
br i1 %174, label %175, label %204
175: ; preds = %172
%176 = load i32, i32* %3
%177 = sext i32 %176 to i64
%178 = getelementptr inbounds [16 x float], [16 x float]* %7, i64 0, i64 %177
%179 = load float, float* %178
%180 = load i32, i32* %3
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds [16 x float], [16 x float]* %8, i64 0, i64 %181
%183 = load float, float* %182
%184 = fadd float %179, %183
%185 = load i32, i32* %3
%186 = sext i32 %185 to i64
%187 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 %186
store float %184, float* %187
%188 = load i32, i32* %3
%189 = sext i32 %188 to i64
%190 = getelementptr inbounds [16 x float], [16 x float]* %7, i64 0, i64 %189
%191 = load float, float* %190
%192 = load i32, i32* %3
%193 = sext i32 %192 to i64
%194 = getelementptr inbounds [16 x float], [16 x float]* %8, i64 0, i64 %193
%195 = load float, float* %194
%196 = fadd float %191, %195
%197 = load i32, i32* %3
%198 = add nsw i32 %197, 1
%199 = sext i32 %198 to i64
%200 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 %199
store float %196, float* %200
br label %201
201: ; preds = %175
%202 = load i32, i32* %3
%203 = add nsw i32 %202, 1
store i32 %203, i32* %3
br label %172
204: ; preds = %172
%205 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 0
%206 = call i32 @fbar(float* %205)
store i32 0, i32* %3
br label %207
207: ; preds = %227, %204
%208 = load i32, i32* %3
%209 = icmp slt i32 %208, 16
br i1 %209, label %210, label %230
210: ; preds = %207
%211 = load i32, i32* %3
%212 = sext i32 %211 to i64
%213 = getelementptr inbounds [16 x float], [16 x float]* %7, i64 0, i64 %212
%214 = load float, float* %213
%215 = fcmp ogt float %214, 0.000000e+00
br i1 %215, label %216, label %221
216: ; preds = %210
%217 = load i32, i32* %3
%218 = sext i32 %217 to i64
%219 = getelementptr inbounds [16 x float], [16 x float]* %7, i64 0, i64 %218
%220 = load float, float* %219
br label %222
221: ; preds = %210
br label %222
222: ; preds = %221, %216
%223 = phi float [ %220, %216 ], [ 0.000000e+00, %221 ]
%224 = load i32, i32* %3
%225 = sext i32 %224 to i64
%226 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 %225
store float %223, float* %226
br label %227
227: ; preds = %222
%228 = load i32, i32* %3
%229 = add nsw i32 %228, 1
store i32 %229, i32* %3
br label %207
230: ; preds = %207
%231 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 0
%232 = call i32 @fbar(float* %231)
store i32 0, i32* %16
store i32 0, i32* %3
br label %233
233: ; preds = %250, %230
%234 = load i32, i32* %3
%235 = icmp slt i32 %234, 16
br i1 %235, label %236, label %253
236: ; preds = %233
%237 = load i32, i32* %3
%238 = sext i32 %237 to i64
%239 = getelementptr inbounds [16 x i8], [16 x i8]* %17, i64 0, i64 %238
%240 = load i8, i8* %239
%241 = sext i8 %240 to i32
%242 = load i32, i32* %3
%243 = sext i32 %242 to i64
%244 = getelementptr inbounds [16 x i8], [16 x i8]* %18, i64 0, i64 %243
%245 = load i8, i8* %244
%246 = sext i8 %245 to i32
%247 = sub nsw i32 %241, %246
%248 = load i32, i32* %16
%249 = add nsw i32 %248, %247
store i32 %249, i32* %16
br label %250
250: ; preds = %236
%251 = load i32, i32* %3
%252 = add nsw i32 %251, 1
store i32 %252, i32* %3
br label %233
253: ; preds = %233
%254 = call i32 @ibar(i32* %16)
store i32 0, i32* %16
store i32 0, i32* %3
br label %255
255: ; preds = %286, %253
%256 = load i32, i32* %3
%257 = icmp slt i32 %256, 16
br i1 %257, label %258, label %289
258: ; preds = %255
store i32 0, i32* %3
br label %259
259: ; preds = %282, %258
%260 = load i32, i32* %3
%261 = icmp slt i32 %260, 16
br i1 %261, label %262, label %285
262: ; preds = %259
%263 = load i32, i32* %3
%264 = sext i32 %263 to i64
%265 = getelementptr inbounds [16 x [16 x i8]], [16 x [16 x i8]]* %19, i64 0, i64 %264
%266 = load i32, i32* %4
%267 = sext i32 %266 to i64
%268 = getelementptr inbounds [16 x i8], [16 x i8]* %265, i64 0, i64 %267
%269 = load i8, i8* %268
%270 = sext i8 %269 to i32
%271 = load i32, i32* %3
%272 = sext i32 %271 to i64
%273 = getelementptr inbounds [16 x [16 x i8]], [16 x [16 x i8]]* %20, i64 0, i64 %272
%274 = load i32, i32* %4
%275 = sext i32 %274 to i64
%276 = getelementptr inbounds [16 x i8], [16 x i8]* %273, i64 0, i64 %275
%277 = load i8, i8* %276
%278 = sext i8 %277 to i32
%279 = sub nsw i32 %270, %278
%280 = load i32, i32* %16
%281 = add nsw i32 %280, %279
store i32 %281, i32* %16
br label %282
282: ; preds = %262
%283 = load i32, i32* %3
%284 = add nsw i32 %283, 1
store i32 %284, i32* %3
br label %259
285: ; preds = %259
br label %286
286: ; preds = %285
%287 = load i32, i32* %3
%288 = add nsw i32 %287, 1
store i32 %288, i32* %3
br label %255
289: ; preds = %255
%290 = call i32 @ibar(i32* %16)
store i32 0, i32* %3
br label %291
291: ; preds = %300, %289
%292 = load i32, i32* %3
%293 = icmp slt i32 %292, 16
br i1 %293, label %294, label %303
294: ; preds = %291
%295 = load i32, i32* %3
%296 = sitofp i32 %295 to float
%297 = load i32, i32* %3
%298 = sext i32 %297 to i64
%299 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 %298
store float %296, float* %299
br label %300
300: ; preds = %294
%301 = load i32, i32* %3
%302 = add nsw i32 %301, 1
store i32 %302, i32* %3
br label %291
303: ; preds = %291
%304 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 0
%305 = call i32 @fbar(float* %304)
store i32 16, i32* %3
br label %306
306: ; preds = %319, %303
%307 = load i32, i32* %3
%308 = icmp sgt i32 %307, 0
br i1 %308, label %309, label %322
309: ; preds = %306
%310 = load i32, i32* %3
%311 = sub nsw i32 %310, 1
%312 = sext i32 %311 to i64
%313 = getelementptr inbounds [16 x float], [16 x float]* %7, i64 0, i64 %312
%314 = load float, float* %313
%315 = load i32, i32* %3
%316 = sub nsw i32 16, %315
%317 = sext i32 %316 to i64
%318 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 %317
store float %314, float* %318
br label %319
319: ; preds = %309
%320 = load i32, i32* %3
%321 = add nsw i32 %320, -1
store i32 %321, i32* %3
br label %306
322: ; preds = %306
store i32 0, i32* %3
br label %323
323: ; preds = %340, %322
%324 = load i32, i32* %3
%325 = icmp slt i32 %324, 16
br i1 %325, label %326, label %343
326: ; preds = %323
%327 = load i32, i32* %3
%328 = sext i32 %327 to i64
%329 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 %328
%330 = load float, float* %329
%331 = load i32, i32* %3
%332 = sub nsw i32 15, %331
%333 = sext i32 %332 to i64
%334 = getelementptr inbounds [16 x float], [16 x float]* %7, i64 0, i64 %333
%335 = load float, float* %334
%336 = fcmp une float %330, %335
br i1 %336, label %337, label %339
337: ; preds = %326
%338 = call i32 (...) @abort()
unreachable
339: ; preds = %326
br label %340
340: ; preds = %339
%341 = load i32, i32* %3
%342 = add nsw i32 %341, 1
store i32 %342, i32* %3
br label %323
343: ; preds = %323
ret i32 0
}

LLVM IR (-O2):
@__const.foo.b = [16 x float] [float 0.000000e+00, float 3.000000e+00, float 6.000000e+00, float 9.000000e+00, float 1.200000e+01, float 1.500000e+01, float 1.800000e+01, float 2.100000e+01, float 2.400000e+01, float 2.700000e+01, float 3.000000e+01, float 3.300000e+01, float 3.600000e+01, float 3.900000e+01, float 4.200000e+01, float 4.500000e+01]
@__const.foo.c = [16 x float] [float 0.000000e+00, float 1.000000e+00, float 2.000000e+00, float 3.000000e+00, float 4.000000e+00, float 5.000000e+00, float 6.000000e+00, float 7.000000e+00, float 8.000000e+00, float 9.000000e+00, float 1.000000e+01, float 1.100000e+01, float 1.200000e+01, float 1.300000e+01, float 1.400000e+01, float 1.500000e+01]
define i32 @foo(i32 %0) {
%2 = alloca [16 x float]
%3 = alloca [16 x i16]
%4 = alloca [16 x i32]
%5 = alloca i32
%6 = bitcast [16 x float]* %2 to i8*
%7 = bitcast [16 x i16]* %3 to i8*
%8 = bitcast [16 x i32]* %4 to i8*
%9 = bitcast i32* %5 to i8*
store i32 0, i32* %5
%10 = getelementptr inbounds [16 x i32], [16 x i32]* %4, i64 0, i64 0
%11 = getelementptr inbounds [16 x i32], [16 x i32]* %4, i64 0, i64 4
%12 = getelementptr inbounds [16 x i32], [16 x i32]* %4, i64 0, i64 8
%13 = getelementptr inbounds [16 x i32], [16 x i32]* %4, i64 0, i64 12
%14 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 0
%15 = call i32 @fbar(float* %14)
%16 = bitcast [16 x float]* %2 to <4 x float>*
store <4 x float> <float 3.000000e+00, float 1.500000e+01, float 2.700000e+01, float 3.900000e+01>, <4 x float>* %16
%17 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 4
%18 = bitcast float* %17 to <4 x float>*
store <4 x float> <float 5.100000e+01, float 6.300000e+01, float 7.500000e+01, float 8.700000e+01>, <4 x float>* %18
%19 = call i32 @fbar(float* %14)
%20 = bitcast [16 x i32]* %4 to <4 x i32>*
store <4 x i32> <i32 0, i32 9, i32 36, i32 81>, <4 x i32>* %20
%21 = bitcast i32* %11 to <4 x i32>*
store <4 x i32> <i32 144, i32 225, i32 324, i32 441>, <4 x i32>* %21
%22 = bitcast i32* %12 to <4 x i32>*
store <4 x i32> <i32 576, i32 729, i32 900, i32 1089>, <4 x i32>* %22
%23 = bitcast i32* %13 to <4 x i32>*
store <4 x i32> <i32 1296, i32 1521, i32 1764, i32 2025>, <4 x i32>* %23
%24 = call i32 @ibar(i32* %10)
%25 = bitcast [16 x i32]* %4 to <4 x i32>*
store <4 x i32> <i32 0, i32 6, i32 12, i32 18>, <4 x i32>* %25
%26 = bitcast [16 x i16]* %3 to <4 x i16>*
store <4 x i16> <i16 0, i16 6, i16 12, i16 18>, <4 x i16>* %26
%27 = getelementptr inbounds [16 x i32], [16 x i32]* %4, i64 0, i64 4
%28 = bitcast i32* %27 to <4 x i32>*
store <4 x i32> <i32 24, i32 30, i32 36, i32 42>, <4 x i32>* %28
%29 = getelementptr inbounds [16 x i16], [16 x i16]* %3, i64 0, i64 4
%30 = bitcast i16* %29 to <4 x i16>*
store <4 x i16> <i16 24, i16 30, i16 36, i16 42>, <4 x i16>* %30
%31 = getelementptr inbounds [16 x i32], [16 x i32]* %4, i64 0, i64 8
%32 = bitcast i32* %31 to <4 x i32>*
store <4 x i32> <i32 48, i32 54, i32 60, i32 66>, <4 x i32>* %32
%33 = getelementptr inbounds [16 x i16], [16 x i16]* %3, i64 0, i64 8
%34 = bitcast i16* %33 to <4 x i16>*
store <4 x i16> <i16 48, i16 54, i16 60, i16 66>, <4 x i16>* %34
%35 = getelementptr inbounds [16 x i32], [16 x i32]* %4, i64 0, i64 12
%36 = bitcast i32* %35 to <4 x i32>*
store <4 x i32> <i32 72, i32 78, i32 84, i32 90>, <4 x i32>* %36
%37 = getelementptr inbounds [16 x i16], [16 x i16]* %3, i64 0, i64 12
%38 = bitcast i16* %37 to <4 x i16>*
store <4 x i16> <i16 72, i16 78, i16 84, i16 90>, <4 x i16>* %38
%39 = call i32 @ibar(i32* %10)
%40 = getelementptr inbounds [16 x i16], [16 x i16]* %3, i64 0, i64 0
%41 = call i32 @sbar(i16* %40)
br label %42
42: ; preds = %42, %1
%43 = phi i64 [ 0, %1 ], [ %58, %42 ]
%44 = getelementptr inbounds [16 x float], [16 x float]* @__const.foo.b, i64 0, i64 %43
%45 = load float, float* %44
%46 = getelementptr inbounds [16 x float], [16 x float]* @__const.foo.c, i64 0, i64 %43
%47 = load float, float* %46
%48 = fadd float %45, %47
%49 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 %43
store float %48, float* %49
%50 = or i64 %43, 1
%51 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 %50
store float %48, float* %51
%52 = getelementptr inbounds [16 x float], [16 x float]* @__const.foo.b, i64 0, i64 %50
%53 = load float, float* %52
%54 = getelementptr inbounds [16 x float], [16 x float]* @__const.foo.c, i64 0, i64 %50
%55 = load float, float* %54
%56 = fadd float %53, %55
%57 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 %50
store float %56, float* %57
%58 = add nuw nsw i64 %43, 2
%59 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 %58
store float %56, float* %59
%60 = icmp eq i64 %58, 16
br i1 %60, label %61, label %42
61: ; preds = %42
%62 = call i32 @fbar(float* %14)
%63 = bitcast [16 x float]* %2 to <4 x float>*
store <4 x float> <float 0.000000e+00, float 3.000000e+00, float 6.000000e+00, float 9.000000e+00>, <4 x float>* %63
%64 = bitcast float* %17 to <4 x float>*
store <4 x float> <float 1.200000e+01, float 1.500000e+01, float 1.800000e+01, float 2.100000e+01>, <4 x float>* %64
%65 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 8
%66 = bitcast float* %65 to <4 x float>*
store <4 x float> <float 2.400000e+01, float 2.700000e+01, float 3.000000e+01, float 3.300000e+01>, <4 x float>* %66
%67 = getelementptr inbounds [16 x float], [16 x float]* %2, i64 0, i64 12
%68 = bitcast float* %67 to <4 x float>*
store <4 x float> <float 3.600000e+01, float 3.900000e+01, float 4.200000e+01, float 4.500000e+01>, <4 x float>* %68
%69 = call i32 @fbar(float* %14)
store i32 0, i32* %5
%70 = call i32 @ibar(i32* %5)
store i32 0, i32* %5
%71 = call i32 @ibar(i32* %5)
%72 = bitcast [16 x float]* %2 to <4 x float>*
store <4 x float> <float 0.000000e+00, float 1.000000e+00, float 2.000000e+00, float 3.000000e+00>, <4 x float>* %72
%73 = bitcast float* %17 to <4 x float>*
store <4 x float> <float 4.000000e+00, float 5.000000e+00, float 6.000000e+00, float 7.000000e+00>, <4 x float>* %73
%74 = bitcast float* %65 to <4 x float>*
store <4 x float> <float 8.000000e+00, float 9.000000e+00, float 1.000000e+01, float 1.100000e+01>, <4 x float>* %74
%75 = bitcast float* %67 to <4 x float>*
store <4 x float> <float 1.200000e+01, float 1.300000e+01, float 1.400000e+01, float 1.500000e+01>, <4 x float>* %75
%76 = call i32 @fbar(float* %14)
ret i32 0
}