#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*/ fbar(float *);
int /*<<< orphan*/ ibar(int *);
int /*<<< orphan*/ sbar(short *);
foo(int n) {
  float a[16 + 1];
  float b[16];
  float c[16];
  float d[16];
  int ia[16];
  int ib[16];
  int ic[16];
  double da[16];
  double db[16];
  short sa[16];
  short sb[16];
  short sc[16];
  int i, j;
  int diff = 0;
  char cb[16];
  char cc[16];
  char image[16][16];
  char block[16][16];
  for (i = 0; i < n; i++) {
    a[i] = b[i];
  }
  fbar(a);
  for (i = 0; i < 16; i++) {
    a[i] = b[i];
  }
  fbar(a);
  for (i = 0; i < 16; i++) {
    da[i] = db[i];
  }
  fbar(a);
  for (i = 0; i < 16; i++) {
    a[i] = 5;
  }
  fbar(a);
  for (i = 0; i < 16; i++) {
    a[i] = b[i] + c[i] + d[i];
  }
  fbar(a);
  for (i = 0; i < 16; i++) {
    a[i] = b[i] * c[i];
  }
  fbar(a);
  for (i = 0; i < 16 / 2; i++) {
    a[i] = b[i + 16 / 2] * c[i + 16 / 2] - b[i] * c[i];
    d[i] = b[i] * c[i + 16 / 2] + b[i + 16 / 2] * c[i];
  }
  fbar(a);
  for (i = 0; i < 16 / 2; i++) {
    a[i] = b[i + 16 / 2] * c[i + 16 / 2] - b[i] * c[i];
    a[i + 16 / 2] = b[i] * c[i + 16 / 2] + b[i + 16 / 2] * c[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 / 2; i++) {
    a[2 * i] = b[2 * i + 1] * c[2 * i + 1] - b[2 * i] * c[2 * i];
    a[2 * i + 1] = 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++) {
    a[i] = b[i] + c[i];
    d[i] = b[i] + c[i];
    ia[i] = ib[i] + ic[i];
  }
  ibar(ia);
  fbar(a);
  fbar(d);
  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);
}


x86 assembly (clang, -O0):
<foo>:
push   %rbp
mov    %rsp,%rbp
sub    $0x560,%rsp
mov    %edi,-0x8(%rbp)
movl   $0x0,-0x33c(%rbp)
movl   $0x0,-0x334(%rbp)
mov    -0x334(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1192 <foo+0x62>
movslq -0x334(%rbp),%rax
movss  -0x90(%rbp,%rax,4),%xmm0
ff ff
movslq -0x334(%rbp),%rax
movss  %xmm0,-0x50(%rbp,%rax,4)
mov    -0x334(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x334(%rbp)
jmp    1152 <foo+0x22>
lea    -0x50(%rbp),%rdi
call   1040 <fbar@plt>
movl   $0x0,-0x334(%rbp)
cmpl   $0x10,-0x334(%rbp)
jge    11e3 <foo+0xb3>
movslq -0x334(%rbp),%rax
movss  -0x90(%rbp,%rax,4),%xmm0
ff ff
movslq -0x334(%rbp),%rax
movss  %xmm0,-0x50(%rbp,%rax,4)
mov    -0x334(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x334(%rbp)
jmp    11a5 <foo+0x75>
lea    -0x50(%rbp),%rdi
call   1040 <fbar@plt>
movl   $0x0,-0x334(%rbp)
cmpl   $0x10,-0x334(%rbp)
jge    1237 <foo+0x107>
movslq -0x334(%rbp),%rax
movsd  -0x2d0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x334(%rbp),%rax
movsd  %xmm0,-0x250(%rbp,%rax,8)
ff ff
mov    -0x334(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x334(%rbp)
jmp    11f6 <foo+0xc6>
lea    -0x50(%rbp),%rdi
call   1040 <fbar@plt>
movl   $0x0,-0x334(%rbp)
cmpl   $0x10,-0x334(%rbp)
jge    1280 <foo+0x150>
movslq -0x334(%rbp),%rax
movss  0xd9a(%rip),%xmm0
movss  %xmm0,-0x50(%rbp,%rax,4)
mov    -0x334(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x334(%rbp)
jmp    124a <foo+0x11a>
lea    -0x50(%rbp),%rdi
call   1040 <fbar@plt>
movl   $0x0,-0x334(%rbp)
cmpl   $0x10,-0x334(%rbp)
jge    12f1 <foo+0x1c1>
movslq -0x334(%rbp),%rax
movss  -0x90(%rbp,%rax,4),%xmm0
ff ff
movslq -0x334(%rbp),%rax
addss  -0xd0(%rbp,%rax,4),%xmm0
ff ff
movslq -0x334(%rbp),%rax
addss  -0x110(%rbp,%rax,4),%xmm0
ff ff
movslq -0x334(%rbp),%rax
movss  %xmm0,-0x50(%rbp,%rax,4)
mov    -0x334(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x334(%rbp)
jmp    1293 <foo+0x163>
lea    -0x50(%rbp),%rdi
call   1040 <fbar@plt>
movl   $0x0,-0x334(%rbp)
cmpl   $0x10,-0x334(%rbp)
jge    1352 <foo+0x222>
movslq -0x334(%rbp),%rax
movss  -0x90(%rbp,%rax,4),%xmm0
ff ff
movslq -0x334(%rbp),%rax
mulss  -0xd0(%rbp,%rax,4),%xmm0
ff ff
movslq -0x334(%rbp),%rax
movss  %xmm0,-0x50(%rbp,%rax,4)
mov    -0x334(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x334(%rbp)
jmp    1304 <foo+0x1d4>
lea    -0x50(%rbp),%rdi
call   1040 <fbar@plt>
movl   $0x0,-0x334(%rbp)
cmpl   $0x8,-0x334(%rbp)
jge    1450 <foo+0x320>
mov    -0x334(%rbp),%eax
add    $0x8,%eax
cltq
movss  -0x90(%rbp,%rax,4),%xmm0
ff ff
mov    -0x334(%rbp),%eax
add    $0x8,%eax
cltq
movss  -0xd0(%rbp,%rax,4),%xmm2
ff ff
movslq -0x334(%rbp),%rax
movss  -0x90(%rbp,%rax,4),%xmm1
ff ff
movslq -0x334(%rbp),%rax
mulss  -0xd0(%rbp,%rax,4),%xmm1
ff ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq -0x334(%rbp),%rax
movss  %xmm0,-0x50(%rbp,%rax,4)
movslq -0x334(%rbp),%rax
movss  -0x90(%rbp,%rax,4),%xmm0
ff ff
mov    -0x334(%rbp),%eax
add    $0x8,%eax
cltq
movss  -0xd0(%rbp,%rax,4),%xmm2
ff ff
mov    -0x334(%rbp),%eax
add    $0x8,%eax
cltq
movss  -0x90(%rbp,%rax,4),%xmm1
ff ff
movslq -0x334(%rbp),%rax
mulss  -0xd0(%rbp,%rax,4),%xmm1
ff ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq -0x334(%rbp),%rax
movss  %xmm0,-0x110(%rbp,%rax,4)
ff ff
mov    -0x334(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x334(%rbp)
jmp    1365 <foo+0x235>
lea    -0x50(%rbp),%rdi
call   1040 <fbar@plt>
movl   $0x0,-0x334(%rbp)
cmpl   $0x8,-0x334(%rbp)
jge    154f <foo+0x41f>
mov    -0x334(%rbp),%eax
add    $0x8,%eax
cltq
movss  -0x90(%rbp,%rax,4),%xmm0
ff ff
mov    -0x334(%rbp),%eax
add    $0x8,%eax
cltq
movss  -0xd0(%rbp,%rax,4),%xmm2
ff ff
movslq -0x334(%rbp),%rax
movss  -0x90(%rbp,%rax,4),%xmm1
ff ff
movslq -0x334(%rbp),%rax
mulss  -0xd0(%rbp,%rax,4),%xmm1
ff ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq -0x334(%rbp),%rax
movss  %xmm0,-0x50(%rbp,%rax,4)
movslq -0x334(%rbp),%rax
movss  -0x90(%rbp,%rax,4),%xmm0
ff ff
mov    -0x334(%rbp),%eax
add    $0x8,%eax
cltq
movss  -0xd0(%rbp,%rax,4),%xmm2
ff ff
mov    -0x334(%rbp),%eax
add    $0x8,%eax
cltq
movss  -0x90(%rbp,%rax,4),%xmm1
ff ff
movslq -0x334(%rbp),%rax
mulss  -0xd0(%rbp,%rax,4),%xmm1
ff ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x334(%rbp),%eax
add    $0x8,%eax
cltq
movss  %xmm0,-0x50(%rbp,%rax,4)
mov    -0x334(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x334(%rbp)
jmp    1463 <foo+0x333>
lea    -0x50(%rbp),%rdi
call   1040 <fbar@plt>
movl   $0x0,-0x334(%rbp)
cmpl   $0x8,-0x334(%rbp)
jge    1669 <foo+0x539>
mov    -0x334(%rbp),%eax
shl    $0x1,%eax
add    $0x1,%eax
cltq
movss  -0x90(%rbp,%rax,4),%xmm0
ff ff
mov    -0x334(%rbp),%eax
shl    $0x1,%eax
add    $0x1,%eax
cltq
movss  -0xd0(%rbp,%rax,4),%xmm2
ff ff
mov    -0x334(%rbp),%eax
shl    $0x1,%eax
cltq
movss  -0x90(%rbp,%rax,4),%xmm1
ff ff
mov    -0x334(%rbp),%eax
shl    $0x1,%eax
cltq
mulss  -0xd0(%rbp,%rax,4),%xmm1
ff ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq -0x334(%rbp),%rax
movss  %xmm0,-0x50(%rbp,%rax,4)
mov    -0x334(%rbp),%eax
shl    $0x1,%eax
cltq
movss  -0x90(%rbp,%rax,4),%xmm0
ff ff
mov    -0x334(%rbp),%eax
shl    $0x1,%eax
add    $0x1,%eax
cltq
movss  -0xd0(%rbp,%rax,4),%xmm2
ff ff
mov    -0x334(%rbp),%eax
shl    $0x1,%eax
add    $0x1,%eax
cltq
movss  -0x90(%rbp,%rax,4),%xmm1
ff ff
mov    -0x334(%rbp),%eax
shl    $0x1,%eax
cltq
mulss  -0xd0(%rbp,%rax,4),%xmm1
ff ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq -0x334(%rbp),%rax
movss  %xmm0,-0x110(%rbp,%rax,4)
ff ff
mov    -0x334(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x334(%rbp)
jmp    1562 <foo+0x432>
lea    -0x50(%rbp),%rdi
call   1040 <fbar@plt>
movl   $0x0,-0x334(%rbp)
cmpl   $0x8,-0x334(%rbp)
jge    178b <foo+0x65b>
mov    -0x334(%rbp),%eax
shl    $0x1,%eax
add    $0x1,%eax
cltq
movss  -0x90(%rbp,%rax,4),%xmm0
ff ff
mov    -0x334(%rbp),%eax
shl    $0x1,%eax
add    $0x1,%eax
cltq
movss  -0xd0(%rbp,%rax,4),%xmm2
ff ff
mov    -0x334(%rbp),%eax
shl    $0x1,%eax
cltq
movss  -0x90(%rbp,%rax,4),%xmm1
ff ff
mov    -0x334(%rbp),%eax
shl    $0x1,%eax
cltq
mulss  -0xd0(%rbp,%rax,4),%xmm1
ff ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x334(%rbp),%eax
shl    $0x1,%eax
cltq
movss  %xmm0,-0x50(%rbp,%rax,4)
mov    -0x334(%rbp),%eax
shl    $0x1,%eax
cltq
movss  -0x90(%rbp,%rax,4),%xmm0
ff ff
mov    -0x334(%rbp),%eax
shl    $0x1,%eax
add    $0x1,%eax
cltq
movss  -0xd0(%rbp,%rax,4),%xmm2
ff ff
mov    -0x334(%rbp),%eax
shl    $0x1,%eax
add    $0x1,%eax
cltq
movss  -0x90(%rbp,%rax,4),%xmm1
ff ff
mov    -0x334(%rbp),%eax
shl    $0x1,%eax
cltq
mulss  -0xd0(%rbp,%rax,4),%xmm1
ff ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x334(%rbp),%eax
shl    $0x1,%eax
add    $0x1,%eax
cltq
movss  %xmm0,-0x50(%rbp,%rax,4)
mov    -0x334(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x334(%rbp)
jmp    167c <foo+0x54c>
lea    -0x50(%rbp),%rdi
call   1040 <fbar@plt>
movl   $0x0,-0x334(%rbp)
cmpl   $0x10,-0x334(%rbp)
jge    17ea <foo+0x6ba>
movslq -0x334(%rbp),%rax
mov    -0x190(%rbp,%rax,4),%ecx
movslq -0x334(%rbp),%rax
imul   -0x1d0(%rbp,%rax,4),%ecx
ff
movslq -0x334(%rbp),%rax
mov    %ecx,-0x150(%rbp,%rax,4)
mov    -0x334(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x334(%rbp)
jmp    179e <foo+0x66e>
lea    -0x150(%rbp),%rdi
call   1050 <ibar@plt>
movl   $0x0,-0x334(%rbp)
cmpl   $0x10,-0x334(%rbp)
jge    18a8 <foo+0x778>
movslq -0x334(%rbp),%rax
movss  -0x90(%rbp,%rax,4),%xmm0
ff ff
movslq -0x334(%rbp),%rax
addss  -0xd0(%rbp,%rax,4),%xmm0
ff ff
movslq -0x334(%rbp),%rax
movss  %xmm0,-0x50(%rbp,%rax,4)
movslq -0x334(%rbp),%rax
movss  -0x90(%rbp,%rax,4),%xmm0
ff ff
movslq -0x334(%rbp),%rax
addss  -0xd0(%rbp,%rax,4),%xmm0
ff ff
movslq -0x334(%rbp),%rax
movss  %xmm0,-0x110(%rbp,%rax,4)
ff ff
movslq -0x334(%rbp),%rax
mov    -0x190(%rbp,%rax,4),%ecx
movslq -0x334(%rbp),%rax
add    -0x1d0(%rbp,%rax,4),%ecx
movslq -0x334(%rbp),%rax
mov    %ecx,-0x150(%rbp,%rax,4)
mov    -0x334(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x334(%rbp)
jmp    1800 <foo+0x6d0>
lea    -0x150(%rbp),%rdi
call   1050 <ibar@plt>
lea    -0x50(%rbp),%rdi
call   1040 <fbar@plt>
lea    -0x110(%rbp),%rdi
call   1040 <fbar@plt>
movl   $0x0,-0x334(%rbp)
cmpl   $0x10,-0x334(%rbp)
jge    1950 <foo+0x820>
movslq -0x334(%rbp),%rax
mov    -0x190(%rbp,%rax,4),%ecx
movslq -0x334(%rbp),%rax
add    -0x1d0(%rbp,%rax,4),%ecx
movslq -0x334(%rbp),%rax
mov    %ecx,-0x150(%rbp,%rax,4)
movslq -0x334(%rbp),%rax
movswl -0x310(%rbp,%rax,2),%eax
ff
movslq -0x334(%rbp),%rcx
movswl -0x330(%rbp,%rcx,2),%ecx
ff
add    %ecx,%eax
mov    %ax,%cx
movslq -0x334(%rbp),%rax
mov    %cx,-0x2f0(%rbp,%rax,2)
ff
mov    -0x334(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x334(%rbp)
jmp    18d3 <foo+0x7a3>
lea    -0x150(%rbp),%rdi
call   1050 <ibar@plt>
lea    -0x2f0(%rbp),%rdi
call   1030 <sbar@plt>
movl   $0x0,-0x334(%rbp)
cmpl   $0x10,-0x334(%rbp)
jge    19f1 <foo+0x8c1>
movslq -0x334(%rbp),%rax
movss  -0x90(%rbp,%rax,4),%xmm0
ff ff
movslq -0x334(%rbp),%rax
addss  -0xd0(%rbp,%rax,4),%xmm0
ff ff
movslq -0x334(%rbp),%rax
movss  %xmm0,-0x50(%rbp,%rax,4)
movslq -0x334(%rbp),%rax
movss  -0x90(%rbp,%rax,4),%xmm0
ff ff
movslq -0x334(%rbp),%rax
addss  -0xd0(%rbp,%rax,4),%xmm0
ff ff
mov    -0x334(%rbp),%eax
add    $0x1,%eax
cltq
movss  %xmm0,-0x50(%rbp,%rax,4)
mov    -0x334(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x334(%rbp)
jmp    1972 <foo+0x842>
lea    -0x50(%rbp),%rdi
call   1040 <fbar@plt>
mov    -0x4(%rbp),%eax
add    $0x560,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<foo>:
push   %r14
push   %rbx
sub    $0x238,%rsp
lea    0x80(%rsp),%r14
mov    %r14,%rdi
call   1040 <fbar@plt>
mov    %r14,%rdi
call   1040 <fbar@plt>
mov    %r14,%rdi
call   1040 <fbar@plt>
movaps 0xe9f(%rip),%xmm0
movaps %xmm0,0x80(%rsp)
movaps %xmm0,0x90(%rsp)
movaps %xmm0,0xa0(%rsp)
movaps %xmm0,0xb0(%rsp)
mov    %r14,%rdi
call   1040 <fbar@plt>
movaps 0x40(%rsp),%xmm0
movaps 0x50(%rsp),%xmm1
movaps 0x60(%rsp),%xmm2
movaps 0x70(%rsp),%xmm3
addps  (%rsp),%xmm0
addps  0x190(%rsp),%xmm0
addps  0x10(%rsp),%xmm1
addps  0x1a0(%rsp),%xmm1
movaps %xmm0,0x80(%rsp)
movaps %xmm1,0x90(%rsp)
addps  0x20(%rsp),%xmm2
addps  0x1b0(%rsp),%xmm2
addps  0x30(%rsp),%xmm3
movaps %xmm2,0xa0(%rsp)
addps  0x1c0(%rsp),%xmm3
movaps %xmm3,0xb0(%rsp)
mov    %r14,%rdi
call   1040 <fbar@plt>
movaps 0x40(%rsp),%xmm0
movaps 0x50(%rsp),%xmm1
movaps 0x60(%rsp),%xmm2
movaps 0x70(%rsp),%xmm3
mulps  (%rsp),%xmm0
mulps  0x10(%rsp),%xmm1
movaps %xmm0,0x80(%rsp)
movaps %xmm1,0x90(%rsp)
mulps  0x20(%rsp),%xmm2
movaps %xmm2,0xa0(%rsp)
mulps  0x30(%rsp),%xmm3
movaps %xmm3,0xb0(%rsp)
mov    %r14,%rdi
call   1040 <fbar@plt>
movaps (%rsp),%xmm0
movaps 0x10(%rsp),%xmm1
mulps  0x40(%rsp),%xmm0
movaps 0x60(%rsp),%xmm2
movaps 0x70(%rsp),%xmm3
mulps  0x20(%rsp),%xmm2
subps  %xmm0,%xmm2
movaps %xmm2,0x80(%rsp)
mulps  0x50(%rsp),%xmm1
mulps  0x30(%rsp),%xmm3
subps  %xmm1,%xmm3
movaps %xmm3,0x90(%rsp)
mov    %r14,%rdi
call   1040 <fbar@plt>
movaps 0x40(%rsp),%xmm1
movaps 0x50(%rsp),%xmm0
movaps 0x60(%rsp),%xmm7
movaps 0x70(%rsp),%xmm3
movaps (%rsp),%xmm4
movaps 0x10(%rsp),%xmm5
movaps 0x20(%rsp),%xmm6
movaps 0x30(%rsp),%xmm8
movaps %xmm7,%xmm2
mulps  %xmm4,%xmm7
mulps  %xmm1,%xmm4
mulps  %xmm6,%xmm2
subps  %xmm4,%xmm2
movaps %xmm2,0x80(%rsp)
mulps  %xmm6,%xmm1
addps  %xmm7,%xmm1
movaps %xmm1,0xa0(%rsp)
movaps %xmm3,%xmm1
mulps  %xmm5,%xmm3
mulps  %xmm0,%xmm5
mulps  %xmm8,%xmm1
subps  %xmm5,%xmm1
movaps %xmm1,0x90(%rsp)
mulps  %xmm8,%xmm0
addps  %xmm3,%xmm0
movaps %xmm0,0xb0(%rsp)
mov    %r14,%rdi
call   1040 <fbar@plt>
movss  0x48(%rsp),%xmm0
movss  0x4c(%rsp),%xmm1
movss  0x50(%rsp),%xmm2
movss  0x54(%rsp),%xmm4
unpcklpd 0x40(%rsp),%xmm0
movss  0x58(%rsp),%xmm3
movlhps %xmm2,%xmm3
shufps $0x22,%xmm3,%xmm0
movss  0x8(%rsp),%xmm3
movss  0xc(%rsp),%xmm2
movss  0x10(%rsp),%xmm5
movss  0x14(%rsp),%xmm6
unpcklpd (%rsp),%xmm3
movss  0x18(%rsp),%xmm7
movlhps %xmm5,%xmm7
shufps $0x22,%xmm7,%xmm3
movhps 0x44(%rsp),%xmm1
movss  0x5c(%rsp),%xmm5
movlhps %xmm4,%xmm5
shufps $0x22,%xmm5,%xmm1
movaps %xmm1,%xmm4
mulps  %xmm3,%xmm1
mulps  %xmm0,%xmm3
movhps 0x4(%rsp),%xmm2
movss  0x1c(%rsp),%xmm5
movlhps %xmm6,%xmm5
shufps $0x22,%xmm5,%xmm2
mulps  %xmm2,%xmm4
subps  %xmm3,%xmm4
movaps %xmm4,0x80(%rsp)
mulps  %xmm0,%xmm2
addps  %xmm1,%xmm2
movaps %xmm2,0x190(%rsp)
movss  0x68(%rsp),%xmm1
movss  0x6c(%rsp),%xmm0
movss  0x70(%rsp),%xmm2
movss  0x74(%rsp),%xmm4
unpcklpd 0x60(%rsp),%xmm1
movss  0x78(%rsp),%xmm3
movlhps %xmm2,%xmm3
shufps $0x22,%xmm3,%xmm1
movss  0x28(%rsp),%xmm3
movss  0x2c(%rsp),%xmm2
movss  0x30(%rsp),%xmm5
movss  0x34(%rsp),%xmm6
unpcklpd 0x20(%rsp),%xmm3
movss  0x38(%rsp),%xmm7
movlhps %xmm5,%xmm7
shufps $0x22,%xmm7,%xmm3
movhps 0x64(%rsp),%xmm0
movss  0x7c(%rsp),%xmm5
movlhps %xmm4,%xmm5
shufps $0x22,%xmm5,%xmm0
movaps %xmm0,%xmm4
mulps  %xmm3,%xmm0
mulps  %xmm1,%xmm3
movhps 0x24(%rsp),%xmm2
movss  0x3c(%rsp),%xmm5
movlhps %xmm6,%xmm5
shufps $0x22,%xmm5,%xmm2
mulps  %xmm2,%xmm4
subps  %xmm3,%xmm4
movaps %xmm4,0x90(%rsp)
mulps  %xmm1,%xmm2
addps  %xmm0,%xmm2
movaps %xmm2,0x1a0(%rsp)
mov    %r14,%rdi
call   1040 <fbar@plt>
movups 0x4(%rsp),%xmm3
movaps (%rsp),%xmm4
movaps 0x40(%rsp),%xmm5
movaps 0x50(%rsp),%xmm2
movaps 0x60(%rsp),%xmm1
movaps %xmm5,%xmm6
shufps $0xb1,%xmm5,%xmm6
movaps 0xb9c(%rip),%xmm8
movaps %xmm5,%xmm7
xorps  %xmm8,%xmm7
movaps %xmm5,%xmm0
movss  %xmm7,%xmm0
shufps $0x23,%xmm7,%xmm5
shufps $0x24,%xmm5,%xmm0
movss  0x8(%rsp),%xmm5
shufps $0x0,%xmm5,%xmm4
mulps  %xmm0,%xmm4
movss  0xc(%rsp),%xmm0
shufps $0x0,%xmm0,%xmm3
mulps  %xmm6,%xmm3
addps  %xmm4,%xmm3
movaps %xmm3,0x80(%rsp)
movups 0x14(%rsp),%xmm0
movaps 0x10(%rsp),%xmm3
movaps %xmm2,%xmm4
shufps $0xb1,%xmm2,%xmm4
movaps %xmm2,%xmm5
xorps  %xmm8,%xmm5
movaps %xmm2,%xmm6
movss  %xmm5,%xmm6
shufps $0x23,%xmm5,%xmm2
shufps $0x24,%xmm2,%xmm6
movss  0x18(%rsp),%xmm2
shufps $0x0,%xmm2,%xmm3
mulps  %xmm6,%xmm3
movss  0x1c(%rsp),%xmm2
shufps $0x0,%xmm2,%xmm0
mulps  %xmm4,%xmm0
addps  %xmm3,%xmm0
movaps %xmm0,0x90(%rsp)
movups 0x24(%rsp),%xmm0
movaps 0x20(%rsp),%xmm2
movaps %xmm1,%xmm3
shufps $0xb1,%xmm1,%xmm3
movaps %xmm1,%xmm4
xorps  %xmm8,%xmm4
movaps %xmm1,%xmm5
movss  %xmm4,%xmm5
shufps $0x23,%xmm4,%xmm1
shufps $0x24,%xmm1,%xmm5
movss  0x28(%rsp),%xmm1
shufps $0x0,%xmm1,%xmm2
mulps  %xmm5,%xmm2
movss  0x2c(%rsp),%xmm1
shufps $0x0,%xmm1,%xmm0
mulps  %xmm3,%xmm0
addps  %xmm2,%xmm0
movaps %xmm0,0xa0(%rsp)
movaps 0x30(%rsp),%xmm0
movaps 0x70(%rsp),%xmm1
movaps %xmm1,%xmm2
shufps $0xb1,%xmm1,%xmm2
xorps  %xmm1,%xmm8
movaps %xmm1,%xmm3
movss  %xmm8,%xmm3
shufps $0x23,%xmm8,%xmm1
shufps $0x24,%xmm1,%xmm3
movss  0x38(%rsp),%xmm1
shufps $0x0,%xmm1,%xmm0
mulps  %xmm3,%xmm0
movss  0x3c(%rsp),%xmm1
movss  0x34(%rsp),%xmm3
shufps $0x0,%xmm1,%xmm3
mulps  %xmm2,%xmm3
addps  %xmm0,%xmm3
movaps %xmm3,0xb0(%rsp)
mov    %r14,%rdi
call   1040 <fbar@plt>
movdqa 0x150(%rsp),%xmm2
movdqa 0x160(%rsp),%xmm3
movdqa 0x170(%rsp),%xmm4
movdqa 0x180(%rsp),%xmm8
movdqa 0x110(%rsp),%xmm5
movdqa 0x120(%rsp),%xmm6
movdqa 0x130(%rsp),%xmm7
movdqa 0x140(%rsp),%xmm1
pshufd $0xf5,%xmm5,%xmm0
pmuludq %xmm2,%xmm5
pshufd $0xe8,%xmm5,%xmm5
pshufd $0xf5,%xmm2,%xmm2
pmuludq %xmm0,%xmm2
pshufd $0xe8,%xmm2,%xmm0
punpckldq %xmm0,%xmm5
movdqa %xmm5,0xd0(%rsp)
pshufd $0xf5,%xmm6,%xmm0
pmuludq %xmm3,%xmm6
pshufd $0xe8,%xmm6,%xmm2
pshufd $0xf5,%xmm3,%xmm3
pmuludq %xmm0,%xmm3
pshufd $0xe8,%xmm3,%xmm0
punpckldq %xmm0,%xmm2
movdqa %xmm2,0xe0(%rsp)
pshufd $0xf5,%xmm7,%xmm0
pmuludq %xmm4,%xmm7
pshufd $0xe8,%xmm7,%xmm2
pshufd $0xf5,%xmm4,%xmm3
pmuludq %xmm0,%xmm3
pshufd $0xe8,%xmm3,%xmm0
punpckldq %xmm0,%xmm2
movdqa %xmm2,0xf0(%rsp)
pshufd $0xf5,%xmm1,%xmm0
pmuludq %xmm8,%xmm1
pshufd $0xe8,%xmm1,%xmm1
pshufd $0xf5,%xmm8,%xmm2
pmuludq %xmm0,%xmm2
pshufd $0xe8,%xmm2,%xmm0
punpckldq %xmm0,%xmm1
movdqa %xmm1,0x100(%rsp)
lea    0xd0(%rsp),%rbx
mov    %rbx,%rdi
call   1050 <ibar@plt>
movaps 0x40(%rsp),%xmm0
movaps 0x50(%rsp),%xmm1
addps  (%rsp),%xmm0
movaps 0x60(%rsp),%xmm2
movaps %xmm0,0x80(%rsp)
movaps %xmm0,0x190(%rsp)
movdqa 0x110(%rsp),%xmm0
movdqa 0x120(%rsp),%xmm3
paddd  0x150(%rsp),%xmm0
movdqa %xmm0,0xd0(%rsp)
addps  0x10(%rsp),%xmm1
movaps %xmm1,0x90(%rsp)
movaps %xmm1,0x1a0(%rsp)
paddd  0x160(%rsp),%xmm3
addps  0x20(%rsp),%xmm2
movdqa %xmm3,0xe0(%rsp)
movaps %xmm2,0xa0(%rsp)
movaps %xmm2,0x1b0(%rsp)
movdqa 0x130(%rsp),%xmm0
movdqa 0x140(%rsp),%xmm1
paddd  0x170(%rsp),%xmm0
movdqa %xmm0,0xf0(%rsp)
movaps 0x70(%rsp),%xmm0
addps  0x30(%rsp),%xmm0
movaps %xmm0,0xb0(%rsp)
movaps %xmm0,0x1c0(%rsp)
paddd  0x180(%rsp),%xmm1
movdqa %xmm1,0x100(%rsp)
mov    %rbx,%rdi
call   1050 <ibar@plt>
mov    %r14,%rdi
call   1040 <fbar@plt>
lea    0x190(%rsp),%rdi
call   1040 <fbar@plt>
movdqa 0x110(%rsp),%xmm0
movdqa 0x120(%rsp),%xmm1
paddd  0x150(%rsp),%xmm0
movdqa 0x130(%rsp),%xmm2
movdqa %xmm0,0xd0(%rsp)
movq   0x1f0(%rsp),%xmm0
movq   0x1d0(%rsp),%xmm3
paddw  %xmm0,%xmm3
movq   0x1f8(%rsp),%xmm0
movq   0x1d8(%rsp),%xmm4
paddw  %xmm0,%xmm4
punpcklqdq %xmm4,%xmm3
movdqa %xmm3,0x210(%rsp)
paddd  0x160(%rsp),%xmm1
movdqa %xmm1,0xe0(%rsp)
paddd  0x170(%rsp),%xmm2
movdqa %xmm2,0xf0(%rsp)
movq   0x200(%rsp),%xmm0
movq   0x1e0(%rsp),%xmm1
paddw  %xmm0,%xmm1
movq   0x208(%rsp),%xmm0
movq   0x1e8(%rsp),%xmm2
paddw  %xmm0,%xmm2
punpcklqdq %xmm2,%xmm1
movdqa %xmm1,0x220(%rsp)
movdqa 0x140(%rsp),%xmm0
paddd  0x180(%rsp),%xmm0
movdqa %xmm0,0x100(%rsp)
mov    %rbx,%rdi
call   1050 <ibar@plt>
lea    0x210(%rsp),%rdi
call   1030 <sbar@plt>
movaps 0x40(%rsp),%xmm0
movaps 0x50(%rsp),%xmm1
movaps 0x60(%rsp),%xmm2
movaps 0x70(%rsp),%xmm3
addps  (%rsp),%xmm0
movaps %xmm0,0x80(%rsp)
addps  0x10(%rsp),%xmm1
movaps %xmm1,0x90(%rsp)
addps  0x20(%rsp),%xmm2
addps  0x30(%rsp),%xmm3
movaps %xmm2,0xa0(%rsp)
movaps %xmm3,0xb0(%rsp)
shufps $0xff,%xmm3,%xmm3
movss  %xmm3,0xc0(%rsp)
mov    %r14,%rdi
call   1040 <fbar@plt>
add    $0x238,%rsp
pop    %rbx
pop    %r14
ret

LLVM IR (-O0):
define i32 @foo(i32 %0) {
%2 = alloca i32
%3 = alloca i32
%4 = alloca [17 x float]
%5 = alloca [16 x float]
%6 = alloca [16 x float]
%7 = alloca [16 x float]
%8 = alloca [16 x i32]
%9 = alloca [16 x i32]
%10 = alloca [16 x i32]
%11 = alloca [16 x double]
%12 = alloca [16 x double]
%13 = alloca [16 x i16]
%14 = alloca [16 x i16]
%15 = alloca [16 x i16]
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca [16 x i8]
%20 = alloca [16 x i8]
%21 = alloca [16 x [16 x i8]]
%22 = alloca [16 x [16 x i8]]
store i32 %0, i32* %3
store i32 0, i32* %18
store i32 0, i32* %16
br label %23
23: ; preds = %35, %1
%24 = load i32, i32* %16
%25 = load i32, i32* %3
%26 = icmp slt i32 %24, %25
br i1 %26, label %27, label %38
27: ; preds = %23
%28 = load i32, i32* %16
%29 = sext i32 %28 to i64
%30 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 %29
%31 = load float, float* %30
%32 = load i32, i32* %16
%33 = sext i32 %32 to i64
%34 = getelementptr inbounds [17 x float], [17 x float]* %4, i64 0, i64 %33
store float %31, float* %34
br label %35
35: ; preds = %27
%36 = load i32, i32* %16
%37 = add nsw i32 %36, 1
store i32 %37, i32* %16
br label %23
38: ; preds = %23
%39 = getelementptr inbounds [17 x float], [17 x float]* %4, i64 0, i64 0
%40 = call i32 @fbar(float* %39)
store i32 0, i32* %16
br label %41
41: ; preds = %52, %38
%42 = load i32, i32* %16
%43 = icmp slt i32 %42, 16
br i1 %43, label %44, label %55
44: ; preds = %41
%45 = load i32, i32* %16
%46 = sext i32 %45 to i64
%47 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 %46
%48 = load float, float* %47
%49 = load i32, i32* %16
%50 = sext i32 %49 to i64
%51 = getelementptr inbounds [17 x float], [17 x float]* %4, i64 0, i64 %50
store float %48, float* %51
br label %52
52: ; preds = %44
%53 = load i32, i32* %16
%54 = add nsw i32 %53, 1
store i32 %54, i32* %16
br label %41
55: ; preds = %41
%56 = getelementptr inbounds [17 x float], [17 x float]* %4, i64 0, i64 0
%57 = call i32 @fbar(float* %56)
store i32 0, i32* %16
br label %58
58: ; preds = %69, %55
%59 = load i32, i32* %16
%60 = icmp slt i32 %59, 16
br i1 %60, label %61, label %72
61: ; preds = %58
%62 = load i32, i32* %16
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds [16 x double], [16 x double]* %12, i64 0, i64 %63
%65 = load double, double* %64
%66 = load i32, i32* %16
%67 = sext i32 %66 to i64
%68 = getelementptr inbounds [16 x double], [16 x double]* %11, i64 0, i64 %67
store double %65, double* %68
br label %69
69: ; preds = %61
%70 = load i32, i32* %16
%71 = add nsw i32 %70, 1
store i32 %71, i32* %16
br label %58
72: ; preds = %58
%73 = getelementptr inbounds [17 x float], [17 x float]* %4, i64 0, i64 0
%74 = call i32 @fbar(float* %73)
store i32 0, i32* %16
br label %75
75: ; preds = %82, %72
%76 = load i32, i32* %16
%77 = icmp slt i32 %76, 16
br i1 %77, label %78, label %85
78: ; preds = %75
%79 = load i32, i32* %16
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds [17 x float], [17 x float]* %4, i64 0, i64 %80
store float 5.000000e+00, float* %81
br label %82
82: ; preds = %78
%83 = load i32, i32* %16
%84 = add nsw i32 %83, 1
store i32 %84, i32* %16
br label %75
85: ; preds = %75
%86 = getelementptr inbounds [17 x float], [17 x float]* %4, i64 0, i64 0
%87 = call i32 @fbar(float* %86)
store i32 0, i32* %16
br label %88
88: ; preds = %109, %85
%89 = load i32, i32* %16
%90 = icmp slt i32 %89, 16
br i1 %90, label %91, label %112
91: ; preds = %88
%92 = load i32, i32* %16
%93 = sext i32 %92 to i64
%94 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 %93
%95 = load float, float* %94
%96 = load i32, i32* %16
%97 = sext i32 %96 to i64
%98 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 %97
%99 = load float, float* %98
%100 = fadd float %95, %99
%101 = load i32, i32* %16
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds [16 x float], [16 x float]* %7, i64 0, i64 %102
%104 = load float, float* %103
%105 = fadd float %100, %104
%106 = load i32, i32* %16
%107 = sext i32 %106 to i64
%108 = getelementptr inbounds [17 x float], [17 x float]* %4, i64 0, i64 %107
store float %105, float* %108
br label %109
109: ; preds = %91
%110 = load i32, i32* %16
%111 = add nsw i32 %110, 1
store i32 %111, i32* %16
br label %88
112: ; preds = %88
%113 = getelementptr inbounds [17 x float], [17 x float]* %4, i64 0, i64 0
%114 = call i32 @fbar(float* %113)
store i32 0, i32* %16
br label %115
115: ; preds = %131, %112
%116 = load i32, i32* %16
%117 = icmp slt i32 %116, 16
br i1 %117, label %118, label %134
118: ; preds = %115
%119 = load i32, i32* %16
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 %120
%122 = load float, float* %121
%123 = load i32, i32* %16
%124 = sext i32 %123 to i64
%125 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 %124
%126 = load float, float* %125
%127 = fmul float %122, %126
%128 = load i32, i32* %16
%129 = sext i32 %128 to i64
%130 = getelementptr inbounds [17 x float], [17 x float]* %4, i64 0, i64 %129
store float %127, float* %130
br label %131
131: ; preds = %118
%132 = load i32, i32* %16
%133 = add nsw i32 %132, 1
store i32 %133, i32* %16
br label %115
134: ; preds = %115
%135 = getelementptr inbounds [17 x float], [17 x float]* %4, i64 0, i64 0
%136 = call i32 @fbar(float* %135)
store i32 0, i32* %16
br label %137
137: ; preds = %188, %134
%138 = load i32, i32* %16
%139 = icmp slt i32 %138, 8
br i1 %139, label %140, label %191
140: ; preds = %137
%141 = load i32, i32* %16
%142 = add nsw i32 %141, 8
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 %143
%145 = load float, float* %144
%146 = load i32, i32* %16
%147 = add nsw i32 %146, 8
%148 = sext i32 %147 to i64
%149 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 %148
%150 = load float, float* %149
%151 = load i32, i32* %16
%152 = sext i32 %151 to i64
%153 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 %152
%154 = load float, float* %153
%155 = load i32, i32* %16
%156 = sext i32 %155 to i64
%157 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 %156
%158 = load float, float* %157
%159 = fmul float %154, %158
%160 = fneg float %159
%161 = call float @llvm.fmuladd.f32(float %145, float %150, float %160)
%162 = load i32, i32* %16
%163 = sext i32 %162 to i64
%164 = getelementptr inbounds [17 x float], [17 x float]* %4, i64 0, i64 %163
store float %161, float* %164
%165 = load i32, i32* %16
%166 = sext i32 %165 to i64
%167 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 %166
%168 = load float, float* %167
%169 = load i32, i32* %16
%170 = add nsw i32 %169, 8
%171 = sext i32 %170 to i64
%172 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 %171
%173 = load float, float* %172
%174 = load i32, i32* %16
%175 = add nsw i32 %174, 8
%176 = sext i32 %175 to i64
%177 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 %176
%178 = load float, float* %177
%179 = load i32, i32* %16
%180 = sext i32 %179 to i64
%181 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 %180
%182 = load float, float* %181
%183 = fmul float %178, %182
%184 = call float @llvm.fmuladd.f32(float %168, float %173, float %183)
%185 = load i32, i32* %16
%186 = sext i32 %185 to i64
%187 = getelementptr inbounds [16 x float], [16 x float]* %7, i64 0, i64 %186
store float %184, float* %187
br label %188
188: ; preds = %140
%189 = load i32, i32* %16
%190 = add nsw i32 %189, 1
store i32 %190, i32* %16
br label %137
191: ; preds = %137
%192 = getelementptr inbounds [17 x float], [17 x float]* %4, i64 0, i64 0
%193 = call i32 @fbar(float* %192)
store i32 0, i32* %16
br label %194
194: ; preds = %246, %191
%195 = load i32, i32* %16
%196 = icmp slt i32 %195, 8
br i1 %196, label %197, label %249
197: ; preds = %194
%198 = load i32, i32* %16
%199 = add nsw i32 %198, 8
%200 = sext i32 %199 to i64
%201 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 %200
%202 = load float, float* %201
%203 = load i32, i32* %16
%204 = add nsw i32 %203, 8
%205 = sext i32 %204 to i64
%206 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 %205
%207 = load float, float* %206
%208 = load i32, i32* %16
%209 = sext i32 %208 to i64
%210 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 %209
%211 = load float, float* %210
%212 = load i32, i32* %16
%213 = sext i32 %212 to i64
%214 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 %213
%215 = load float, float* %214
%216 = fmul float %211, %215
%217 = fneg float %216
%218 = call float @llvm.fmuladd.f32(float %202, float %207, float %217)
%219 = load i32, i32* %16
%220 = sext i32 %219 to i64
%221 = getelementptr inbounds [17 x float], [17 x float]* %4, i64 0, i64 %220
store float %218, float* %221
%222 = load i32, i32* %16
%223 = sext i32 %222 to i64
%224 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 %223
%225 = load float, float* %224
%226 = load i32, i32* %16
%227 = add nsw i32 %226, 8
%228 = sext i32 %227 to i64
%229 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 %228
%230 = load float, float* %229
%231 = load i32, i32* %16
%232 = add nsw i32 %231, 8
%233 = sext i32 %232 to i64
%234 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 %233
%235 = load float, float* %234
%236 = load i32, i32* %16
%237 = sext i32 %236 to i64
%238 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 %237
%239 = load float, float* %238
%240 = fmul float %235, %239
%241 = call float @llvm.fmuladd.f32(float %225, float %230, float %240)
%242 = load i32, i32* %16
%243 = add nsw i32 %242, 8
%244 = sext i32 %243 to i64
%245 = getelementptr inbounds [17 x float], [17 x float]* %4, i64 0, i64 %244
store float %241, float* %245
br label %246
246: ; preds = %197
%247 = load i32, i32* %16
%248 = add nsw i32 %247, 1
store i32 %248, i32* %16
br label %194
249: ; preds = %194
%250 = getelementptr inbounds [17 x float], [17 x float]* %4, i64 0, i64 0
%251 = call i32 @fbar(float* %250)
store i32 0, i32* %16
br label %252
252: ; preds = %311, %249
%253 = load i32, i32* %16
%254 = icmp slt i32 %253, 8
br i1 %254, label %255, label %314
255: ; preds = %252
%256 = load i32, i32* %16
%257 = mul nsw i32 2, %256
%258 = add nsw i32 %257, 1
%259 = sext i32 %258 to i64
%260 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 %259
%261 = load float, float* %260
%262 = load i32, i32* %16
%263 = mul nsw i32 2, %262
%264 = add nsw i32 %263, 1
%265 = sext i32 %264 to i64
%266 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 %265
%267 = load float, float* %266
%268 = load i32, i32* %16
%269 = mul nsw i32 2, %268
%270 = sext i32 %269 to i64
%271 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 %270
%272 = load float, float* %271
%273 = load i32, i32* %16
%274 = mul nsw i32 2, %273
%275 = sext i32 %274 to i64
%276 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 %275
%277 = load float, float* %276
%278 = fmul float %272, %277
%279 = fneg float %278
%280 = call float @llvm.fmuladd.f32(float %261, float %267, float %279)
%281 = load i32, i32* %16
%282 = sext i32 %281 to i64
%283 = getelementptr inbounds [17 x float], [17 x float]* %4, i64 0, i64 %282
store float %280, float* %283
%284 = load i32, i32* %16
%285 = mul nsw i32 2, %284
%286 = sext i32 %285 to i64
%287 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 %286
%288 = load float, float* %287
%289 = load i32, i32* %16
%290 = mul nsw i32 2, %289
%291 = add nsw i32 %290, 1
%292 = sext i32 %291 to i64
%293 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 %292
%294 = load float, float* %293
%295 = load i32, i32* %16
%296 = mul nsw i32 2, %295
%297 = add nsw i32 %296, 1
%298 = sext i32 %297 to i64
%299 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 %298
%300 = load float, float* %299
%301 = load i32, i32* %16
%302 = mul nsw i32 2, %301
%303 = sext i32 %302 to i64
%304 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 %303
%305 = load float, float* %304
%306 = fmul float %300, %305
%307 = call float @llvm.fmuladd.f32(float %288, float %294, float %306)
%308 = load i32, i32* %16
%309 = sext i32 %308 to i64
%310 = getelementptr inbounds [16 x float], [16 x float]* %7, i64 0, i64 %309
store float %307, float* %310
br label %311
311: ; preds = %255
%312 = load i32, i32* %16
%313 = add nsw i32 %312, 1
store i32 %313, i32* %16
br label %252
314: ; preds = %252
%315 = getelementptr inbounds [17 x float], [17 x float]* %4, i64 0, i64 0
%316 = call i32 @fbar(float* %315)
store i32 0, i32* %16
br label %317
317: ; preds = %379, %314
%318 = load i32, i32* %16
%319 = icmp slt i32 %318, 8
br i1 %319, label %320, label %382
320: ; preds = %317
%321 = load i32, i32* %16
%322 = mul nsw i32 2, %321
%323 = add nsw i32 %322, 1
%324 = sext i32 %323 to i64
%325 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 %324
%326 = load float, float* %325
%327 = load i32, i32* %16
%328 = mul nsw i32 2, %327
%329 = add nsw i32 %328, 1
%330 = sext i32 %329 to i64
%331 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 %330
%332 = load float, float* %331
%333 = load i32, i32* %16
%334 = mul nsw i32 2, %333
%335 = sext i32 %334 to i64
%336 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 %335
%337 = load float, float* %336
%338 = load i32, i32* %16
%339 = mul nsw i32 2, %338
%340 = sext i32 %339 to i64
%341 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 %340
%342 = load float, float* %341
%343 = fmul float %337, %342
%344 = fneg float %343
%345 = call float @llvm.fmuladd.f32(float %326, float %332, float %344)
%346 = load i32, i32* %16
%347 = mul nsw i32 2, %346
%348 = sext i32 %347 to i64
%349 = getelementptr inbounds [17 x float], [17 x float]* %4, i64 0, i64 %348
store float %345, float* %349
%350 = load i32, i32* %16
%351 = mul nsw i32 2, %350
%352 = sext i32 %351 to i64
%353 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 %352
%354 = load float, float* %353
%355 = load i32, i32* %16
%356 = mul nsw i32 2, %355
%357 = add nsw i32 %356, 1
%358 = sext i32 %357 to i64
%359 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 %358
%360 = load float, float* %359
%361 = load i32, i32* %16
%362 = mul nsw i32 2, %361
%363 = add nsw i32 %362, 1
%364 = sext i32 %363 to i64
%365 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 %364
%366 = load float, float* %365
%367 = load i32, i32* %16
%368 = mul nsw i32 2, %367
%369 = sext i32 %368 to i64
%370 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 %369
%371 = load float, float* %370
%372 = fmul float %366, %371
%373 = call float @llvm.fmuladd.f32(float %354, float %360, float %372)
%374 = load i32, i32* %16
%375 = mul nsw i32 2, %374
%376 = add nsw i32 %375, 1
%377 = sext i32 %376 to i64
%378 = getelementptr inbounds [17 x float], [17 x float]* %4, i64 0, i64 %377
store float %373, float* %378
br label %379
379: ; preds = %320
%380 = load i32, i32* %16
%381 = add nsw i32 %380, 1
store i32 %381, i32* %16
br label %317
382: ; preds = %317
%383 = getelementptr inbounds [17 x float], [17 x float]* %4, i64 0, i64 0
%384 = call i32 @fbar(float* %383)
store i32 0, i32* %16
br label %385
385: ; preds = %401, %382
%386 = load i32, i32* %16
%387 = icmp slt i32 %386, 16
br i1 %387, label %388, label %404
388: ; preds = %385
%389 = load i32, i32* %16
%390 = sext i32 %389 to i64
%391 = getelementptr inbounds [16 x i32], [16 x i32]* %9, i64 0, i64 %390
%392 = load i32, i32* %391
%393 = load i32, i32* %16
%394 = sext i32 %393 to i64
%395 = getelementptr inbounds [16 x i32], [16 x i32]* %10, i64 0, i64 %394
%396 = load i32, i32* %395
%397 = mul nsw i32 %392, %396
%398 = load i32, i32* %16
%399 = sext i32 %398 to i64
%400 = getelementptr inbounds [16 x i32], [16 x i32]* %8, i64 0, i64 %399
store i32 %397, i32* %400
br label %401
401: ; preds = %388
%402 = load i32, i32* %16
%403 = add nsw i32 %402, 1
store i32 %403, i32* %16
br label %385
404: ; preds = %385
%405 = getelementptr inbounds [16 x i32], [16 x i32]* %8, i64 0, i64 0
%406 = call i32 @ibar(i32* %405)
store i32 0, i32* %16
br label %407
407: ; preds = %447, %404
%408 = load i32, i32* %16
%409 = icmp slt i32 %408, 16
br i1 %409, label %410, label %450
410: ; preds = %407
%411 = load i32, i32* %16
%412 = sext i32 %411 to i64
%413 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 %412
%414 = load float, float* %413
%415 = load i32, i32* %16
%416 = sext i32 %415 to i64
%417 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 %416
%418 = load float, float* %417
%419 = fadd float %414, %418
%420 = load i32, i32* %16
%421 = sext i32 %420 to i64
%422 = getelementptr inbounds [17 x float], [17 x float]* %4, i64 0, i64 %421
store float %419, float* %422
%423 = load i32, i32* %16
%424 = sext i32 %423 to i64
%425 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 %424
%426 = load float, float* %425
%427 = load i32, i32* %16
%428 = sext i32 %427 to i64
%429 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 %428
%430 = load float, float* %429
%431 = fadd float %426, %430
%432 = load i32, i32* %16
%433 = sext i32 %432 to i64
%434 = getelementptr inbounds [16 x float], [16 x float]* %7, i64 0, i64 %433
store float %431, float* %434
%435 = load i32, i32* %16
%436 = sext i32 %435 to i64
%437 = getelementptr inbounds [16 x i32], [16 x i32]* %9, i64 0, i64 %436
%438 = load i32, i32* %437
%439 = load i32, i32* %16
%440 = sext i32 %439 to i64
%441 = getelementptr inbounds [16 x i32], [16 x i32]* %10, i64 0, i64 %440
%442 = load i32, i32* %441
%443 = add nsw i32 %438, %442
%444 = load i32, i32* %16
%445 = sext i32 %444 to i64
%446 = getelementptr inbounds [16 x i32], [16 x i32]* %8, i64 0, i64 %445
store i32 %443, i32* %446
br label %447
447: ; preds = %410
%448 = load i32, i32* %16
%449 = add nsw i32 %448, 1
store i32 %449, i32* %16
br label %407
450: ; preds = %407
%451 = getelementptr inbounds [16 x i32], [16 x i32]* %8, i64 0, i64 0
%452 = call i32 @ibar(i32* %451)
%453 = getelementptr inbounds [17 x float], [17 x float]* %4, i64 0, i64 0
%454 = call i32 @fbar(float* %453)
%455 = getelementptr inbounds [16 x float], [16 x float]* %7, i64 0, i64 0
%456 = call i32 @fbar(float* %455)
store i32 0, i32* %16
br label %457
457: ; preds = %488, %450
%458 = load i32, i32* %16
%459 = icmp slt i32 %458, 16
br i1 %459, label %460, label %491
460: ; preds = %457
%461 = load i32, i32* %16
%462 = sext i32 %461 to i64
%463 = getelementptr inbounds [16 x i32], [16 x i32]* %9, i64 0, i64 %462
%464 = load i32, i32* %463
%465 = load i32, i32* %16
%466 = sext i32 %465 to i64
%467 = getelementptr inbounds [16 x i32], [16 x i32]* %10, i64 0, i64 %466
%468 = load i32, i32* %467
%469 = add nsw i32 %464, %468
%470 = load i32, i32* %16
%471 = sext i32 %470 to i64
%472 = getelementptr inbounds [16 x i32], [16 x i32]* %8, i64 0, i64 %471
store i32 %469, i32* %472
%473 = load i32, i32* %16
%474 = sext i32 %473 to i64
%475 = getelementptr inbounds [16 x i16], [16 x i16]* %14, i64 0, i64 %474
%476 = load i16, i16* %475
%477 = sext i16 %476 to i32
%478 = load i32, i32* %16
%479 = sext i32 %478 to i64
%480 = getelementptr inbounds [16 x i16], [16 x i16]* %15, i64 0, i64 %479
%481 = load i16, i16* %480
%482 = sext i16 %481 to i32
%483 = add nsw i32 %477, %482
%484 = trunc i32 %483 to i16
%485 = load i32, i32* %16
%486 = sext i32 %485 to i64
%487 = getelementptr inbounds [16 x i16], [16 x i16]* %13, i64 0, i64 %486
store i16 %484, i16* %487
br label %488
488: ; preds = %460
%489 = load i32, i32* %16
%490 = add nsw i32 %489, 1
store i32 %490, i32* %16
br label %457
491: ; preds = %457
%492 = getelementptr inbounds [16 x i32], [16 x i32]* %8, i64 0, i64 0
%493 = call i32 @ibar(i32* %492)
%494 = getelementptr inbounds [16 x i16], [16 x i16]* %13, i64 0, i64 0
%495 = call i32 @sbar(i16* %494)
store i32 0, i32* %16
br label %496
496: ; preds = %525, %491
%497 = load i32, i32* %16
%498 = icmp slt i32 %497, 16
br i1 %498, label %499, label %528
499: ; preds = %496
%500 = load i32, i32* %16
%501 = sext i32 %500 to i64
%502 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 %501
%503 = load float, float* %502
%504 = load i32, i32* %16
%505 = sext i32 %504 to i64
%506 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 %505
%507 = load float, float* %506
%508 = fadd float %503, %507
%509 = load i32, i32* %16
%510 = sext i32 %509 to i64
%511 = getelementptr inbounds [17 x float], [17 x float]* %4, i64 0, i64 %510
store float %508, float* %511
%512 = load i32, i32* %16
%513 = sext i32 %512 to i64
%514 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 %513
%515 = load float, float* %514
%516 = load i32, i32* %16
%517 = sext i32 %516 to i64
%518 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 %517
%519 = load float, float* %518
%520 = fadd float %515, %519
%521 = load i32, i32* %16
%522 = add nsw i32 %521, 1
%523 = sext i32 %522 to i64
%524 = getelementptr inbounds [17 x float], [17 x float]* %4, i64 0, i64 %523
store float %520, float* %524
br label %525
525: ; preds = %499
%526 = load i32, i32* %16
%527 = add nsw i32 %526, 1
store i32 %527, i32* %16
br label %496
528: ; preds = %496
%529 = getelementptr inbounds [17 x float], [17 x float]* %4, i64 0, i64 0
%530 = call i32 @fbar(float* %529)
%531 = load i32, i32* %2
ret i32 %531
}

LLVM IR (-O2):
define i32 @foo(i32 %0) {
%2 = alloca [17 x float]
%3 = bitcast [17 x float]* %2 to i8*
%4 = alloca [16 x float]
%5 = bitcast [16 x float]* %4 to i8*
%6 = alloca [16 x float]
%7 = alloca [16 x float]
%8 = alloca [16 x i32]
%9 = alloca [16 x i32]
%10 = alloca [16 x i32]
%11 = alloca [16 x i16]
%12 = alloca [16 x i16]
%13 = alloca [16 x i16]
%14 = bitcast [16 x float]* %6 to i8*
%15 = bitcast [16 x float]* %7 to i8*
%16 = bitcast [16 x i32]* %8 to i8*
%17 = bitcast [16 x i32]* %9 to i8*
%18 = bitcast [16 x i32]* %10 to i8*
%19 = bitcast [16 x i16]* %11 to i8*
%20 = bitcast [16 x i16]* %12 to i8*
%21 = bitcast [16 x i16]* %13 to i8*
%22 = getelementptr inbounds [17 x float], [17 x float]* %2, i64 0, i64 0
%23 = call i32 @fbar(float* %22)
%24 = call i32 @fbar(float* %22)
%25 = call i32 @fbar(float* %22)
%26 = bitcast [17 x float]* %2 to <4 x float>*
store <4 x float> <float 5.000000e+00, float 5.000000e+00, float 5.000000e+00, float 5.000000e+00>, <4 x float>* %26
%27 = getelementptr inbounds [17 x float], [17 x float]* %2, i64 0, i64 4
%28 = bitcast float* %27 to <4 x float>*
store <4 x float> <float 5.000000e+00, float 5.000000e+00, float 5.000000e+00, float 5.000000e+00>, <4 x float>* %28
%29 = getelementptr inbounds [17 x float], [17 x float]* %2, i64 0, i64 8
%30 = bitcast float* %29 to <4 x float>*
store <4 x float> <float 5.000000e+00, float 5.000000e+00, float 5.000000e+00, float 5.000000e+00>, <4 x float>* %30
%31 = getelementptr inbounds [17 x float], [17 x float]* %2, i64 0, i64 12
%32 = bitcast float* %31 to <4 x float>*
store <4 x float> <float 5.000000e+00, float 5.000000e+00, float 5.000000e+00, float 5.000000e+00>, <4 x float>* %32
%33 = call i32 @fbar(float* %22)
%34 = getelementptr inbounds [16 x float], [16 x float]* %4, i64 0, i64 1
%35 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 1
%36 = getelementptr inbounds [16 x float], [16 x float]* %4, i64 0, i64 2
%37 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 2
%38 = getelementptr inbounds [16 x float], [16 x float]* %4, i64 0, i64 3
%39 = bitcast [16 x float]* %4 to <4 x float>*
%40 = load <4 x float>, <4 x float>* %39
%41 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 3
%42 = bitcast [16 x float]* %6 to <4 x float>*
%43 = load <4 x float>, <4 x float>* %42
%44 = fadd <4 x float> %40, %43
%45 = bitcast [16 x float]* %7 to <4 x float>*
%46 = load <4 x float>, <4 x float>* %45
%47 = fadd <4 x float> %44, %46
%48 = bitcast [17 x float]* %2 to <4 x float>*
store <4 x float> %47, <4 x float>* %48
%49 = getelementptr inbounds [16 x float], [16 x float]* %4, i64 0, i64 4
%50 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 4
%51 = getelementptr inbounds [16 x float], [16 x float]* %7, i64 0, i64 4
%52 = getelementptr inbounds [16 x float], [16 x float]* %4, i64 0, i64 5
%53 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 5
%54 = getelementptr inbounds [16 x float], [16 x float]* %4, i64 0, i64 6
%55 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 6
%56 = getelementptr inbounds [16 x float], [16 x float]* %4, i64 0, i64 7
%57 = bitcast float* %49 to <4 x float>*
%58 = load <4 x float>, <4 x float>* %57
%59 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 7
%60 = bitcast float* %50 to <4 x float>*
%61 = load <4 x float>, <4 x float>* %60
%62 = fadd <4 x float> %58, %61
%63 = bitcast float* %51 to <4 x float>*
%64 = load <4 x float>, <4 x float>* %63
%65 = fadd <4 x float> %62, %64
%66 = bitcast float* %27 to <4 x float>*
store <4 x float> %65, <4 x float>* %66
%67 = getelementptr inbounds [16 x float], [16 x float]* %4, i64 0, i64 8
%68 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 8
%69 = getelementptr inbounds [16 x float], [16 x float]* %7, i64 0, i64 8
%70 = getelementptr inbounds [16 x float], [16 x float]* %4, i64 0, i64 9
%71 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 9
%72 = getelementptr inbounds [16 x float], [16 x float]* %4, i64 0, i64 10
%73 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 10
%74 = getelementptr inbounds [16 x float], [16 x float]* %4, i64 0, i64 11
%75 = bitcast float* %67 to <4 x float>*
%76 = load <4 x float>, <4 x float>* %75
%77 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 11
%78 = bitcast float* %68 to <4 x float>*
%79 = load <4 x float>, <4 x float>* %78
%80 = fadd <4 x float> %76, %79
%81 = bitcast float* %69 to <4 x float>*
%82 = load <4 x float>, <4 x float>* %81
%83 = fadd <4 x float> %80, %82
%84 = bitcast float* %29 to <4 x float>*
store <4 x float> %83, <4 x float>* %84
%85 = getelementptr inbounds [16 x float], [16 x float]* %4, i64 0, i64 12
%86 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 12
%87 = getelementptr inbounds [16 x float], [16 x float]* %7, i64 0, i64 12
%88 = getelementptr inbounds [16 x float], [16 x float]* %4, i64 0, i64 13
%89 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 13
%90 = getelementptr inbounds [16 x float], [16 x float]* %4, i64 0, i64 14
%91 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 14
%92 = getelementptr inbounds [16 x float], [16 x float]* %4, i64 0, i64 15
%93 = bitcast float* %85 to <4 x float>*
%94 = load <4 x float>, <4 x float>* %93
%95 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 15
%96 = bitcast float* %86 to <4 x float>*
%97 = load <4 x float>, <4 x float>* %96
%98 = fadd <4 x float> %94, %97
%99 = bitcast float* %87 to <4 x float>*
%100 = load <4 x float>, <4 x float>* %99
%101 = fadd <4 x float> %98, %100
%102 = bitcast float* %31 to <4 x float>*
store <4 x float> %101, <4 x float>* %102
%103 = call i32 @fbar(float* %22)
%104 = bitcast [16 x float]* %4 to <4 x float>*
%105 = load <4 x float>, <4 x float>* %104
%106 = bitcast [16 x float]* %6 to <4 x float>*
%107 = load <4 x float>, <4 x float>* %106
%108 = fmul <4 x float> %105, %107
%109 = bitcast [17 x float]* %2 to <4 x float>*
store <4 x float> %108, <4 x float>* %109
%110 = bitcast float* %49 to <4 x float>*
%111 = load <4 x float>, <4 x float>* %110
%112 = bitcast float* %50 to <4 x float>*
%113 = load <4 x float>, <4 x float>* %112
%114 = fmul <4 x float> %111, %113
%115 = bitcast float* %27 to <4 x float>*
store <4 x float> %114, <4 x float>* %115
%116 = bitcast float* %67 to <4 x float>*
%117 = load <4 x float>, <4 x float>* %116
%118 = bitcast float* %68 to <4 x float>*
%119 = load <4 x float>, <4 x float>* %118
%120 = fmul <4 x float> %117, %119
%121 = bitcast float* %29 to <4 x float>*
store <4 x float> %120, <4 x float>* %121
%122 = bitcast float* %85 to <4 x float>*
%123 = load <4 x float>, <4 x float>* %122
%124 = bitcast float* %86 to <4 x float>*
%125 = load <4 x float>, <4 x float>* %124
%126 = fmul <4 x float> %123, %125
%127 = bitcast float* %31 to <4 x float>*
store <4 x float> %126, <4 x float>* %127
%128 = call i32 @fbar(float* %22)
%129 = bitcast float* %67 to <4 x float>*
%130 = load <4 x float>, <4 x float>* %129
%131 = bitcast float* %68 to <4 x float>*
%132 = load <4 x float>, <4 x float>* %131
%133 = bitcast [16 x float]* %4 to <4 x float>*
%134 = load <4 x float>, <4 x float>* %133
%135 = bitcast [16 x float]* %6 to <4 x float>*
%136 = load <4 x float>, <4 x float>* %135
%137 = fneg <4 x float> %134
%138 = fmul <4 x float> %136, %137
%139 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %130, <4 x float> %132, <4 x float> %138)
%140 = bitcast [17 x float]* %2 to <4 x float>*
store <4 x float> %139, <4 x float>* %140
%141 = bitcast float* %85 to <4 x float>*
%142 = load <4 x float>, <4 x float>* %141
%143 = bitcast float* %86 to <4 x float>*
%144 = load <4 x float>, <4 x float>* %143
%145 = bitcast float* %49 to <4 x float>*
%146 = load <4 x float>, <4 x float>* %145
%147 = bitcast float* %50 to <4 x float>*
%148 = load <4 x float>, <4 x float>* %147
%149 = fneg <4 x float> %146
%150 = fmul <4 x float> %148, %149
%151 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %142, <4 x float> %144, <4 x float> %150)
%152 = bitcast float* %27 to <4 x float>*
store <4 x float> %151, <4 x float>* %152
%153 = call i32 @fbar(float* %22)
%154 = bitcast float* %67 to <4 x float>*
%155 = load <4 x float>, <4 x float>* %154
%156 = bitcast [16 x float]* %6 to <4 x float>*
%157 = load <4 x float>, <4 x float>* %156
%158 = bitcast float* %68 to <4 x float>*
%159 = load <4 x float>, <4 x float>* %158
%160 = bitcast [16 x float]* %4 to <4 x float>*
%161 = load <4 x float>, <4 x float>* %160
%162 = fneg <4 x float> %161
%163 = fmul <4 x float> %157, %162
%164 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %155, <4 x float> %159, <4 x float> %163)
%165 = bitcast [17 x float]* %2 to <4 x float>*
store <4 x float> %164, <4 x float>* %165
%166 = fmul <4 x float> %155, %157
%167 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %161, <4 x float> %159, <4 x float> %166)
%168 = bitcast float* %29 to <4 x float>*
store <4 x float> %167, <4 x float>* %168
%169 = bitcast float* %85 to <4 x float>*
%170 = load <4 x float>, <4 x float>* %169
%171 = bitcast float* %50 to <4 x float>*
%172 = load <4 x float>, <4 x float>* %171
%173 = bitcast float* %86 to <4 x float>*
%174 = load <4 x float>, <4 x float>* %173
%175 = bitcast float* %49 to <4 x float>*
%176 = load <4 x float>, <4 x float>* %175
%177 = fneg <4 x float> %176
%178 = fmul <4 x float> %172, %177
%179 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %170, <4 x float> %174, <4 x float> %178)
%180 = bitcast float* %27 to <4 x float>*
store <4 x float> %179, <4 x float>* %180
%181 = fmul <4 x float> %170, %172
%182 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %176, <4 x float> %174, <4 x float> %181)
%183 = bitcast float* %31 to <4 x float>*
store <4 x float> %182, <4 x float>* %183
%184 = call i32 @fbar(float* %22)
%185 = bitcast float* %34 to <4 x float>*
%186 = load <4 x float>, <4 x float>* %185
%187 = bitcast float* %35 to <4 x float>*
%188 = load <4 x float>, <4 x float>* %187
%189 = bitcast [16 x float]* %4 to <4 x float>*
%190 = load <4 x float>, <4 x float>* %189
%191 = bitcast [16 x float]* %6 to <4 x float>*
%192 = load <4 x float>, <4 x float>* %191
%193 = load float, float* %38
%194 = load float, float* %41
%195 = load float, float* %36
%196 = load float, float* %37
%197 = load float, float* %52
%198 = load float, float* %53
%199 = load float, float* %49
%200 = load float, float* %50
%201 = load float, float* %56
%202 = load float, float* %59
%203 = load float, float* %54
%204 = load float, float* %55
%205 = insertelement <4 x float> %190, float %195, i64 1
%206 = insertelement <4 x float> %205, float %199, i64 2
%207 = insertelement <4 x float> %206, float %203, i64 3
%208 = fneg <4 x float> %207
%209 = insertelement <4 x float> %192, float %196, i64 1
%210 = insertelement <4 x float> %209, float %200, i64 2
%211 = insertelement <4 x float> %210, float %204, i64 3
%212 = fmul <4 x float> %211, %208
%213 = insertelement <4 x float> %186, float %193, i64 1
%214 = insertelement <4 x float> %213, float %197, i64 2
%215 = insertelement <4 x float> %214, float %201, i64 3
%216 = insertelement <4 x float> %188, float %194, i64 1
%217 = insertelement <4 x float> %216, float %198, i64 2
%218 = insertelement <4 x float> %217, float %202, i64 3
%219 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %215, <4 x float> %218, <4 x float> %212)
%220 = bitcast [17 x float]* %2 to <4 x float>*
store <4 x float> %219, <4 x float>* %220
%221 = fmul <4 x float> %215, %211
%222 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %207, <4 x float> %218, <4 x float> %221)
%223 = bitcast [16 x float]* %7 to <4 x float>*
store <4 x float> %222, <4 x float>* %223
%224 = bitcast float* %70 to <4 x float>*
%225 = load <4 x float>, <4 x float>* %224
%226 = bitcast float* %71 to <4 x float>*
%227 = load <4 x float>, <4 x float>* %226
%228 = bitcast float* %67 to <4 x float>*
%229 = load <4 x float>, <4 x float>* %228
%230 = bitcast float* %68 to <4 x float>*
%231 = load <4 x float>, <4 x float>* %230
%232 = load float, float* %74
%233 = load float, float* %77
%234 = load float, float* %72
%235 = load float, float* %73
%236 = load float, float* %88
%237 = load float, float* %89
%238 = load float, float* %85
%239 = load float, float* %86
%240 = load float, float* %92
%241 = load float, float* %95
%242 = load float, float* %90
%243 = load float, float* %91
%244 = insertelement <4 x float> %229, float %234, i64 1
%245 = insertelement <4 x float> %244, float %238, i64 2
%246 = insertelement <4 x float> %245, float %242, i64 3
%247 = fneg <4 x float> %246
%248 = insertelement <4 x float> %231, float %235, i64 1
%249 = insertelement <4 x float> %248, float %239, i64 2
%250 = insertelement <4 x float> %249, float %243, i64 3
%251 = fmul <4 x float> %250, %247
%252 = insertelement <4 x float> %225, float %232, i64 1
%253 = insertelement <4 x float> %252, float %236, i64 2
%254 = insertelement <4 x float> %253, float %240, i64 3
%255 = insertelement <4 x float> %227, float %233, i64 1
%256 = insertelement <4 x float> %255, float %237, i64 2
%257 = insertelement <4 x float> %256, float %241, i64 3
%258 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %254, <4 x float> %257, <4 x float> %251)
%259 = bitcast float* %27 to <4 x float>*
store <4 x float> %258, <4 x float>* %259
%260 = fmul <4 x float> %254, %250
%261 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %246, <4 x float> %257, <4 x float> %260)
%262 = bitcast float* %51 to <4 x float>*
store <4 x float> %261, <4 x float>* %262
%263 = call i32 @fbar(float* %22)
%264 = bitcast float* %35 to <4 x float>*
%265 = load <4 x float>, <4 x float>* %264
%266 = bitcast [16 x float]* %6 to <4 x float>*
%267 = load <4 x float>, <4 x float>* %266
%268 = bitcast [16 x float]* %4 to <4 x float>*
%269 = load <4 x float>, <4 x float>* %268
%270 = shufflevector <4 x float> %269, <4 x float> poison, <4 x i32> <i32 1, i32 0, i32 3, i32 2>
%271 = extractelement <4 x float> %269, i64 0
%272 = fneg float %271
%273 = load float, float* %41
%274 = load float, float* %37
%275 = extractelement <4 x float> %269, i64 2
%276 = fneg float %275
%277 = insertelement <4 x float> poison, float %272, i64 0
%278 = extractelement <4 x float> %269, i64 1
%279 = insertelement <4 x float> %277, float %278, i64 1
%280 = insertelement <4 x float> %279, float %276, i64 2
%281 = shufflevector <4 x float> %280, <4 x float> %269, <4 x i32> <i32 0, i32 1, i32 2, i32 7>
%282 = insertelement <4 x float> %267, float %274, i64 1
%283 = shufflevector <4 x float> %282, <4 x float> poison, <4 x i32> <i32 0, i32 0, i32 1, i32 1>
%284 = fmul <4 x float> %281, %283
%285 = insertelement <4 x float> %265, float %273, i64 1
%286 = shufflevector <4 x float> %285, <4 x float> poison, <4 x i32> <i32 0, i32 0, i32 1, i32 1>
%287 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %270, <4 x float> %286, <4 x float> %284)
%288 = bitcast [17 x float]* %2 to <4 x float>*
store <4 x float> %287, <4 x float>* %288
%289 = bitcast float* %53 to <4 x float>*
%290 = load <4 x float>, <4 x float>* %289
%291 = bitcast float* %50 to <4 x float>*
%292 = load <4 x float>, <4 x float>* %291
%293 = bitcast float* %49 to <4 x float>*
%294 = load <4 x float>, <4 x float>* %293
%295 = shufflevector <4 x float> %294, <4 x float> poison, <4 x i32> <i32 1, i32 0, i32 3, i32 2>
%296 = extractelement <4 x float> %294, i64 0
%297 = fneg float %296
%298 = load float, float* %59
%299 = load float, float* %55
%300 = extractelement <4 x float> %294, i64 2
%301 = fneg float %300
%302 = insertelement <4 x float> poison, float %297, i64 0
%303 = extractelement <4 x float> %294, i64 1
%304 = insertelement <4 x float> %302, float %303, i64 1
%305 = insertelement <4 x float> %304, float %301, i64 2
%306 = shufflevector <4 x float> %305, <4 x float> %294, <4 x i32> <i32 0, i32 1, i32 2, i32 7>
%307 = insertelement <4 x float> %292, float %299, i64 1
%308 = shufflevector <4 x float> %307, <4 x float> poison, <4 x i32> <i32 0, i32 0, i32 1, i32 1>
%309 = fmul <4 x float> %306, %308
%310 = insertelement <4 x float> %290, float %298, i64 1
%311 = shufflevector <4 x float> %310, <4 x float> poison, <4 x i32> <i32 0, i32 0, i32 1, i32 1>
%312 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %295, <4 x float> %311, <4 x float> %309)
%313 = bitcast float* %27 to <4 x float>*
store <4 x float> %312, <4 x float>* %313
%314 = bitcast float* %71 to <4 x float>*
%315 = load <4 x float>, <4 x float>* %314
%316 = bitcast float* %68 to <4 x float>*
%317 = load <4 x float>, <4 x float>* %316
%318 = bitcast float* %67 to <4 x float>*
%319 = load <4 x float>, <4 x float>* %318
%320 = shufflevector <4 x float> %319, <4 x float> poison, <4 x i32> <i32 1, i32 0, i32 3, i32 2>
%321 = extractelement <4 x float> %319, i64 0
%322 = fneg float %321
%323 = load float, float* %77
%324 = load float, float* %73
%325 = extractelement <4 x float> %319, i64 2
%326 = fneg float %325
%327 = insertelement <4 x float> poison, float %322, i64 0
%328 = extractelement <4 x float> %319, i64 1
%329 = insertelement <4 x float> %327, float %328, i64 1
%330 = insertelement <4 x float> %329, float %326, i64 2
%331 = shufflevector <4 x float> %330, <4 x float> %319, <4 x i32> <i32 0, i32 1, i32 2, i32 7>
%332 = insertelement <4 x float> %317, float %324, i64 1
%333 = shufflevector <4 x float> %332, <4 x float> poison, <4 x i32> <i32 0, i32 0, i32 1, i32 1>
%334 = fmul <4 x float> %331, %333
%335 = insertelement <4 x float> %315, float %323, i64 1
%336 = shufflevector <4 x float> %335, <4 x float> poison, <4 x i32> <i32 0, i32 0, i32 1, i32 1>
%337 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %320, <4 x float> %336, <4 x float> %334)
%338 = bitcast float* %29 to <4 x float>*
store <4 x float> %337, <4 x float>* %338
%339 = load float, float* %89
%340 = bitcast float* %86 to <4 x float>*
%341 = load <4 x float>, <4 x float>* %340
%342 = bitcast float* %85 to <4 x float>*
%343 = load <4 x float>, <4 x float>* %342
%344 = shufflevector <4 x float> %343, <4 x float> poison, <4 x i32> <i32 1, i32 0, i32 3, i32 2>
%345 = extractelement <4 x float> %343, i64 0
%346 = fneg float %345
%347 = load float, float* %95
%348 = load float, float* %91
%349 = extractelement <4 x float> %343, i64 2
%350 = fneg float %349
%351 = insertelement <4 x float> poison, float %346, i64 0
%352 = extractelement <4 x float> %343, i64 1
%353 = insertelement <4 x float> %351, float %352, i64 1
%354 = insertelement <4 x float> %353, float %350, i64 2
%355 = shufflevector <4 x float> %354, <4 x float> %343, <4 x i32> <i32 0, i32 1, i32 2, i32 7>
%356 = insertelement <4 x float> %341, float %348, i64 1
%357 = shufflevector <4 x float> %356, <4 x float> poison, <4 x i32> <i32 0, i32 0, i32 1, i32 1>
%358 = fmul <4 x float> %355, %357
%359 = insertelement <4 x float> poison, float %339, i64 0
%360 = insertelement <4 x float> %359, float %347, i64 1
%361 = shufflevector <4 x float> %360, <4 x float> poison, <4 x i32> <i32 0, i32 0, i32 1, i32 1>
%362 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %344, <4 x float> %361, <4 x float> %358)
%363 = bitcast float* %31 to <4 x float>*
store <4 x float> %362, <4 x float>* %363
%364 = call i32 @fbar(float* %22)
%365 = getelementptr inbounds [16 x i32], [16 x i32]* %8, i64 0, i64 0
%366 = bitcast [16 x i32]* %9 to <4 x i32>*
%367 = load <4 x i32>, <4 x i32>* %366
%368 = bitcast [16 x i32]* %10 to <4 x i32>*
%369 = load <4 x i32>, <4 x i32>* %368
%370 = mul nsw <4 x i32> %369, %367
%371 = bitcast [16 x i32]* %8 to <4 x i32>*
store <4 x i32> %370, <4 x i32>* %371
%372 = getelementptr inbounds [16 x i32], [16 x i32]* %9, i64 0, i64 4
%373 = getelementptr inbounds [16 x i32], [16 x i32]* %10, i64 0, i64 4
%374 = getelementptr inbounds [16 x i32], [16 x i32]* %8, i64 0, i64 4
%375 = bitcast i32* %372 to <4 x i32>*
%376 = load <4 x i32>, <4 x i32>* %375
%377 = bitcast i32* %373 to <4 x i32>*
%378 = load <4 x i32>, <4 x i32>* %377
%379 = mul nsw <4 x i32> %378, %376
%380 = bitcast i32* %374 to <4 x i32>*
store <4 x i32> %379, <4 x i32>* %380
%381 = getelementptr inbounds [16 x i32], [16 x i32]* %9, i64 0, i64 8
%382 = getelementptr inbounds [16 x i32], [16 x i32]* %10, i64 0, i64 8
%383 = getelementptr inbounds [16 x i32], [16 x i32]* %8, i64 0, i64 8
%384 = bitcast i32* %381 to <4 x i32>*
%385 = load <4 x i32>, <4 x i32>* %384
%386 = bitcast i32* %382 to <4 x i32>*
%387 = load <4 x i32>, <4 x i32>* %386
%388 = mul nsw <4 x i32> %387, %385
%389 = bitcast i32* %383 to <4 x i32>*
store <4 x i32> %388, <4 x i32>* %389
%390 = getelementptr inbounds [16 x i32], [16 x i32]* %9, i64 0, i64 12
%391 = getelementptr inbounds [16 x i32], [16 x i32]* %10, i64 0, i64 12
%392 = getelementptr inbounds [16 x i32], [16 x i32]* %8, i64 0, i64 12
%393 = bitcast i32* %390 to <4 x i32>*
%394 = load <4 x i32>, <4 x i32>* %393
%395 = bitcast i32* %391 to <4 x i32>*
%396 = load <4 x i32>, <4 x i32>* %395
%397 = mul nsw <4 x i32> %396, %394
%398 = bitcast i32* %392 to <4 x i32>*
store <4 x i32> %397, <4 x i32>* %398
%399 = call i32 @ibar(i32* %365)
%400 = getelementptr inbounds [16 x float], [16 x float]* %7, i64 0, i64 0
%401 = bitcast [16 x float]* %4 to <4 x float>*
%402 = load <4 x float>, <4 x float>* %401
%403 = bitcast [16 x float]* %6 to <4 x float>*
%404 = load <4 x float>, <4 x float>* %403
%405 = fadd <4 x float> %402, %404
%406 = bitcast [17 x float]* %2 to <4 x float>*
store <4 x float> %405, <4 x float>* %406
%407 = bitcast [16 x float]* %7 to <4 x float>*
store <4 x float> %405, <4 x float>* %407
%408 = bitcast [16 x i32]* %9 to <4 x i32>*
%409 = load <4 x i32>, <4 x i32>* %408
%410 = bitcast [16 x i32]* %10 to <4 x i32>*
%411 = load <4 x i32>, <4 x i32>* %410
%412 = add nsw <4 x i32> %411, %409
%413 = bitcast [16 x i32]* %8 to <4 x i32>*
store <4 x i32> %412, <4 x i32>* %413
%414 = getelementptr inbounds [16 x float], [16 x float]* %4, i64 0, i64 4
%415 = bitcast float* %414 to <4 x float>*
%416 = load <4 x float>, <4 x float>* %415
%417 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 4
%418 = bitcast float* %417 to <4 x float>*
%419 = load <4 x float>, <4 x float>* %418
%420 = fadd <4 x float> %416, %419
%421 = getelementptr inbounds [17 x float], [17 x float]* %2, i64 0, i64 4
%422 = bitcast float* %421 to <4 x float>*
store <4 x float> %420, <4 x float>* %422
%423 = getelementptr inbounds [16 x float], [16 x float]* %7, i64 0, i64 4
%424 = bitcast float* %423 to <4 x float>*
store <4 x float> %420, <4 x float>* %424
%425 = getelementptr inbounds [16 x i32], [16 x i32]* %9, i64 0, i64 4
%426 = bitcast i32* %425 to <4 x i32>*
%427 = load <4 x i32>, <4 x i32>* %426
%428 = getelementptr inbounds [16 x i32], [16 x i32]* %10, i64 0, i64 4
%429 = bitcast i32* %428 to <4 x i32>*
%430 = load <4 x i32>, <4 x i32>* %429
%431 = add nsw <4 x i32> %430, %427
%432 = getelementptr inbounds [16 x i32], [16 x i32]* %8, i64 0, i64 4
%433 = bitcast i32* %432 to <4 x i32>*
store <4 x i32> %431, <4 x i32>* %433
%434 = getelementptr inbounds [16 x float], [16 x float]* %4, i64 0, i64 8
%435 = bitcast float* %434 to <4 x float>*
%436 = load <4 x float>, <4 x float>* %435
%437 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 8
%438 = bitcast float* %437 to <4 x float>*
%439 = load <4 x float>, <4 x float>* %438
%440 = fadd <4 x float> %436, %439
%441 = getelementptr inbounds [17 x float], [17 x float]* %2, i64 0, i64 8
%442 = bitcast float* %441 to <4 x float>*
store <4 x float> %440, <4 x float>* %442
%443 = getelementptr inbounds [16 x float], [16 x float]* %7, i64 0, i64 8
%444 = bitcast float* %443 to <4 x float>*
store <4 x float> %440, <4 x float>* %444
%445 = getelementptr inbounds [16 x i32], [16 x i32]* %9, i64 0, i64 8
%446 = bitcast i32* %445 to <4 x i32>*
%447 = load <4 x i32>, <4 x i32>* %446
%448 = getelementptr inbounds [16 x i32], [16 x i32]* %10, i64 0, i64 8
%449 = bitcast i32* %448 to <4 x i32>*
%450 = load <4 x i32>, <4 x i32>* %449
%451 = add nsw <4 x i32> %450, %447
%452 = getelementptr inbounds [16 x i32], [16 x i32]* %8, i64 0, i64 8
%453 = bitcast i32* %452 to <4 x i32>*
store <4 x i32> %451, <4 x i32>* %453
%454 = getelementptr inbounds [16 x float], [16 x float]* %4, i64 0, i64 12
%455 = bitcast float* %454 to <4 x float>*
%456 = load <4 x float>, <4 x float>* %455
%457 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 12
%458 = bitcast float* %457 to <4 x float>*
%459 = load <4 x float>, <4 x float>* %458
%460 = fadd <4 x float> %456, %459
%461 = getelementptr inbounds [17 x float], [17 x float]* %2, i64 0, i64 12
%462 = bitcast float* %461 to <4 x float>*
store <4 x float> %460, <4 x float>* %462
%463 = getelementptr inbounds [16 x float], [16 x float]* %7, i64 0, i64 12
%464 = bitcast float* %463 to <4 x float>*
store <4 x float> %460, <4 x float>* %464
%465 = getelementptr inbounds [16 x i32], [16 x i32]* %9, i64 0, i64 12
%466 = bitcast i32* %465 to <4 x i32>*
%467 = load <4 x i32>, <4 x i32>* %466
%468 = getelementptr inbounds [16 x i32], [16 x i32]* %10, i64 0, i64 12
%469 = bitcast i32* %468 to <4 x i32>*
%470 = load <4 x i32>, <4 x i32>* %469
%471 = add nsw <4 x i32> %470, %467
%472 = getelementptr inbounds [16 x i32], [16 x i32]* %8, i64 0, i64 12
%473 = bitcast i32* %472 to <4 x i32>*
store <4 x i32> %471, <4 x i32>* %473
%474 = call i32 @ibar(i32* %365)
%475 = call i32 @fbar(float* %22)
%476 = call i32 @fbar(float* %400)
%477 = bitcast [16 x i32]* %9 to <4 x i32>*
%478 = load <4 x i32>, <4 x i32>* %477
%479 = bitcast [16 x i32]* %10 to <4 x i32>*
%480 = load <4 x i32>, <4 x i32>* %479
%481 = add nsw <4 x i32> %480, %478
%482 = bitcast [16 x i32]* %8 to <4 x i32>*
store <4 x i32> %481, <4 x i32>* %482
%483 = bitcast [16 x i16]* %12 to <4 x i16>*
%484 = load <4 x i16>, <4 x i16>* %483
%485 = bitcast [16 x i16]* %13 to <4 x i16>*
%486 = load <4 x i16>, <4 x i16>* %485
%487 = add <4 x i16> %486, %484
%488 = bitcast [16 x i16]* %11 to <4 x i16>*
store <4 x i16> %487, <4 x i16>* %488
%489 = getelementptr inbounds [16 x i32], [16 x i32]* %9, i64 0, i64 4
%490 = bitcast i32* %489 to <4 x i32>*
%491 = load <4 x i32>, <4 x i32>* %490
%492 = getelementptr inbounds [16 x i32], [16 x i32]* %10, i64 0, i64 4
%493 = bitcast i32* %492 to <4 x i32>*
%494 = load <4 x i32>, <4 x i32>* %493
%495 = add nsw <4 x i32> %494, %491
%496 = getelementptr inbounds [16 x i32], [16 x i32]* %8, i64 0, i64 4
%497 = bitcast i32* %496 to <4 x i32>*
store <4 x i32> %495, <4 x i32>* %497
%498 = getelementptr inbounds [16 x i16], [16 x i16]* %12, i64 0, i64 4
%499 = bitcast i16* %498 to <4 x i16>*
%500 = load <4 x i16>, <4 x i16>* %499
%501 = getelementptr inbounds [16 x i16], [16 x i16]* %13, i64 0, i64 4
%502 = bitcast i16* %501 to <4 x i16>*
%503 = load <4 x i16>, <4 x i16>* %502
%504 = add <4 x i16> %503, %500
%505 = getelementptr inbounds [16 x i16], [16 x i16]* %11, i64 0, i64 4
%506 = bitcast i16* %505 to <4 x i16>*
store <4 x i16> %504, <4 x i16>* %506
%507 = getelementptr inbounds [16 x i32], [16 x i32]* %9, i64 0, i64 8
%508 = bitcast i32* %507 to <4 x i32>*
%509 = load <4 x i32>, <4 x i32>* %508
%510 = getelementptr inbounds [16 x i32], [16 x i32]* %10, i64 0, i64 8
%511 = bitcast i32* %510 to <4 x i32>*
%512 = load <4 x i32>, <4 x i32>* %511
%513 = add nsw <4 x i32> %512, %509
%514 = getelementptr inbounds [16 x i32], [16 x i32]* %8, i64 0, i64 8
%515 = bitcast i32* %514 to <4 x i32>*
store <4 x i32> %513, <4 x i32>* %515
%516 = getelementptr inbounds [16 x i16], [16 x i16]* %12, i64 0, i64 8
%517 = bitcast i16* %516 to <4 x i16>*
%518 = load <4 x i16>, <4 x i16>* %517
%519 = getelementptr inbounds [16 x i16], [16 x i16]* %13, i64 0, i64 8
%520 = bitcast i16* %519 to <4 x i16>*
%521 = load <4 x i16>, <4 x i16>* %520
%522 = add <4 x i16> %521, %518
%523 = getelementptr inbounds [16 x i16], [16 x i16]* %11, i64 0, i64 8
%524 = bitcast i16* %523 to <4 x i16>*
store <4 x i16> %522, <4 x i16>* %524
%525 = getelementptr inbounds [16 x i32], [16 x i32]* %9, i64 0, i64 12
%526 = bitcast i32* %525 to <4 x i32>*
%527 = load <4 x i32>, <4 x i32>* %526
%528 = getelementptr inbounds [16 x i32], [16 x i32]* %10, i64 0, i64 12
%529 = bitcast i32* %528 to <4 x i32>*
%530 = load <4 x i32>, <4 x i32>* %529
%531 = add nsw <4 x i32> %530, %527
%532 = getelementptr inbounds [16 x i32], [16 x i32]* %8, i64 0, i64 12
%533 = bitcast i32* %532 to <4 x i32>*
store <4 x i32> %531, <4 x i32>* %533
%534 = getelementptr inbounds [16 x i16], [16 x i16]* %12, i64 0, i64 12
%535 = bitcast i16* %534 to <4 x i16>*
%536 = load <4 x i16>, <4 x i16>* %535
%537 = getelementptr inbounds [16 x i16], [16 x i16]* %13, i64 0, i64 12
%538 = bitcast i16* %537 to <4 x i16>*
%539 = load <4 x i16>, <4 x i16>* %538
%540 = add <4 x i16> %539, %536
%541 = getelementptr inbounds [16 x i16], [16 x i16]* %11, i64 0, i64 12
%542 = bitcast i16* %541 to <4 x i16>*
store <4 x i16> %540, <4 x i16>* %542
%543 = call i32 @ibar(i32* %365)
%544 = getelementptr inbounds [16 x i16], [16 x i16]* %11, i64 0, i64 0
%545 = call i32 @sbar(i16* %544)
%546 = bitcast [16 x float]* %4 to <4 x float>*
%547 = load <4 x float>, <4 x float>* %546
%548 = bitcast [16 x float]* %6 to <4 x float>*
%549 = load <4 x float>, <4 x float>* %548
%550 = fadd <4 x float> %547, %549
%551 = bitcast [17 x float]* %2 to <4 x float>*
store <4 x float> %550, <4 x float>* %551
%552 = bitcast float* %49 to <4 x float>*
%553 = load <4 x float>, <4 x float>* %552
%554 = bitcast float* %50 to <4 x float>*
%555 = load <4 x float>, <4 x float>* %554
%556 = fadd <4 x float> %553, %555
%557 = bitcast float* %27 to <4 x float>*
store <4 x float> %556, <4 x float>* %557
%558 = bitcast float* %67 to <4 x float>*
%559 = load <4 x float>, <4 x float>* %558
%560 = bitcast float* %68 to <4 x float>*
%561 = load <4 x float>, <4 x float>* %560
%562 = fadd <4 x float> %559, %561
%563 = bitcast float* %29 to <4 x float>*
store <4 x float> %562, <4 x float>* %563
%564 = bitcast float* %85 to <4 x float>*
%565 = load <4 x float>, <4 x float>* %564
%566 = bitcast float* %86 to <4 x float>*
%567 = load <4 x float>, <4 x float>* %566
%568 = fadd <4 x float> %565, %567
%569 = bitcast float* %31 to <4 x float>*
store <4 x float> %568, <4 x float>* %569
%570 = getelementptr inbounds [17 x float], [17 x float]* %2, i64 0, i64 16
%571 = extractelement <4 x float> %568, i64 3
store float %571, float* %570
%572 = call i32 @fbar(float* %22)
ret i32 undef
}