#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];
  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];
  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] = b[i];
  }
  fbar(a);
  for (i = 0; i < 16; i++) {
    a[i] = b[i] + c[i] + d[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++) {
    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    $0x460,%rsp
mov    %edi,-0x8(%rbp)
movl   $0x0,-0x23c(%rbp)
movl   $0x0,-0x23c(%rbp)
movl   $0x0,-0x234(%rbp)
cmpl   $0x10,-0x234(%rbp)
jge    11a9 <foo+0x79>
movslq -0x234(%rbp),%rax
movsbl -0x250(%rbp,%rax,1),%eax
ff
movslq -0x234(%rbp),%rcx
movsbl -0x260(%rbp,%rcx,1),%ecx
ff
sub    %ecx,%eax
add    -0x23c(%rbp),%eax
mov    %eax,-0x23c(%rbp)
mov    -0x234(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x234(%rbp)
jmp    115c <foo+0x2c>
lea    -0x23c(%rbp),%rdi
call   1050 <ibar@plt>
movl   $0x0,-0x23c(%rbp)
movl   $0x0,-0x234(%rbp)
cmpl   $0x10,-0x234(%rbp)
jge    1268 <foo+0x138>
movl   $0x0,-0x234(%rbp)
cmpl   $0x10,-0x234(%rbp)
jge    124f <foo+0x11f>
movslq -0x234(%rbp),%rcx
lea    -0x360(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x238(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
movslq -0x234(%rbp),%rdx
lea    -0x460(%rbp),%rcx
shl    $0x4,%rdx
add    %rdx,%rcx
movslq -0x238(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
sub    %ecx,%eax
add    -0x23c(%rbp),%eax
mov    %eax,-0x23c(%rbp)
mov    -0x234(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x234(%rbp)
jmp    11e0 <foo+0xb0>
jmp    1254 <foo+0x124>
mov    -0x234(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x234(%rbp)
jmp    11c9 <foo+0x99>
lea    -0x23c(%rbp),%rdi
call   1050 <ibar@plt>
movl   $0x0,-0x234(%rbp)
cmpl   $0x10,-0x234(%rbp)
jge    12bc <foo+0x18c>
movslq -0x234(%rbp),%rax
movss  -0x90(%rbp,%rax,4),%xmm0
ff ff
movslq -0x234(%rbp),%rax
movss  %xmm0,-0x50(%rbp,%rax,4)
mov    -0x234(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x234(%rbp)
jmp    127e <foo+0x14e>
lea    -0x50(%rbp),%rdi
call   1040 <fbar@plt>
movl   $0x0,-0x234(%rbp)
cmpl   $0x10,-0x234(%rbp)
jge    132d <foo+0x1fd>
movslq -0x234(%rbp),%rax
movss  -0x90(%rbp,%rax,4),%xmm0
ff ff
movslq -0x234(%rbp),%rax
addss  -0xd0(%rbp,%rax,4),%xmm0
ff ff
movslq -0x234(%rbp),%rax
addss  -0x110(%rbp,%rax,4),%xmm0
ff ff
movslq -0x234(%rbp),%rax
movss  %xmm0,-0x50(%rbp,%rax,4)
mov    -0x234(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x234(%rbp)
jmp    12cf <foo+0x19f>
lea    -0x50(%rbp),%rdi
call   1040 <fbar@plt>
movl   $0x0,-0x234(%rbp)
cmpl   $0x8,-0x234(%rbp)
jge    1447 <foo+0x317>
mov    -0x234(%rbp),%eax
shl    $0x1,%eax
add    $0x1,%eax
cltq
movss  -0x90(%rbp,%rax,4),%xmm0
ff ff
mov    -0x234(%rbp),%eax
shl    $0x1,%eax
add    $0x1,%eax
cltq
movss  -0xd0(%rbp,%rax,4),%xmm2
ff ff
mov    -0x234(%rbp),%eax
shl    $0x1,%eax
cltq
movss  -0x90(%rbp,%rax,4),%xmm1
ff ff
mov    -0x234(%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 -0x234(%rbp),%rax
movss  %xmm0,-0x50(%rbp,%rax,4)
mov    -0x234(%rbp),%eax
shl    $0x1,%eax
cltq
movss  -0x90(%rbp,%rax,4),%xmm0
ff ff
mov    -0x234(%rbp),%eax
shl    $0x1,%eax
add    $0x1,%eax
cltq
movss  -0xd0(%rbp,%rax,4),%xmm2
ff ff
mov    -0x234(%rbp),%eax
shl    $0x1,%eax
add    $0x1,%eax
cltq
movss  -0x90(%rbp,%rax,4),%xmm1
ff ff
mov    -0x234(%rbp),%eax
shl    $0x1,%eax
cltq
mulss  -0xd0(%rbp,%rax,4),%xmm1
ff ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq -0x234(%rbp),%rax
movss  %xmm0,-0x110(%rbp,%rax,4)
ff ff
mov    -0x234(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x234(%rbp)
jmp    1340 <foo+0x210>
lea    -0x50(%rbp),%rdi
call   1040 <fbar@plt>
movl   $0x0,-0x234(%rbp)
cmpl   $0x10,-0x234(%rbp)
jge    1502 <foo+0x3d2>
movslq -0x234(%rbp),%rax
movss  -0x90(%rbp,%rax,4),%xmm0
ff ff
movslq -0x234(%rbp),%rax
addss  -0xd0(%rbp,%rax,4),%xmm0
ff ff
movslq -0x234(%rbp),%rax
movss  %xmm0,-0x50(%rbp,%rax,4)
movslq -0x234(%rbp),%rax
movss  -0x90(%rbp,%rax,4),%xmm0
ff ff
movslq -0x234(%rbp),%rax
addss  -0xd0(%rbp,%rax,4),%xmm0
ff ff
movslq -0x234(%rbp),%rax
movss  %xmm0,-0x110(%rbp,%rax,4)
ff ff
movslq -0x234(%rbp),%rax
mov    -0x190(%rbp,%rax,4),%ecx
movslq -0x234(%rbp),%rax
add    -0x1d0(%rbp,%rax,4),%ecx
movslq -0x234(%rbp),%rax
mov    %ecx,-0x150(%rbp,%rax,4)
mov    -0x234(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x234(%rbp)
jmp    145a <foo+0x32a>
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,-0x234(%rbp)
cmpl   $0x10,-0x234(%rbp)
jge    15aa <foo+0x47a>
movslq -0x234(%rbp),%rax
mov    -0x190(%rbp,%rax,4),%ecx
movslq -0x234(%rbp),%rax
add    -0x1d0(%rbp,%rax,4),%ecx
movslq -0x234(%rbp),%rax
mov    %ecx,-0x150(%rbp,%rax,4)
movslq -0x234(%rbp),%rax
movswl -0x210(%rbp,%rax,2),%eax
ff
movslq -0x234(%rbp),%rcx
movswl -0x230(%rbp,%rcx,2),%ecx
ff
add    %ecx,%eax
mov    %ax,%cx
movslq -0x234(%rbp),%rax
mov    %cx,-0x1f0(%rbp,%rax,2)
ff
mov    -0x234(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x234(%rbp)
jmp    152d <foo+0x3fd>
lea    -0x150(%rbp),%rdi
call   1050 <ibar@plt>
lea    -0x1f0(%rbp),%rdi
call   1030 <sbar@plt>
movl   $0x0,-0x234(%rbp)
cmpl   $0x10,-0x234(%rbp)
jge    164b <foo+0x51b>
movslq -0x234(%rbp),%rax
movss  -0x90(%rbp,%rax,4),%xmm0
ff ff
movslq -0x234(%rbp),%rax
addss  -0xd0(%rbp,%rax,4),%xmm0
ff ff
movslq -0x234(%rbp),%rax
movss  %xmm0,-0x50(%rbp,%rax,4)
movslq -0x234(%rbp),%rax
movss  -0x90(%rbp,%rax,4),%xmm0
ff ff
movslq -0x234(%rbp),%rax
addss  -0xd0(%rbp,%rax,4),%xmm0
ff ff
mov    -0x234(%rbp),%eax
add    $0x1,%eax
cltq
movss  %xmm0,-0x50(%rbp,%rax,4)
mov    -0x234(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x234(%rbp)
jmp    15cc <foo+0x49c>
lea    -0x50(%rbp),%rdi
call   1040 <fbar@plt>
mov    -0x4(%rbp),%eax
add    $0x460,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<foo>:
push   %r14
push   %rbx
sub    $0x2a8,%rsp
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>
lea    0x90(%rsp),%rbx
mov    %rbx,%rdi
call   1040 <fbar@plt>
movss  0x50(%rsp),%xmm0
addss  0x10(%rsp),%xmm0
addss  0xe0(%rsp),%xmm0
movss  %xmm0,0x90(%rsp)
movups 0x54(%rsp),%xmm0
movups 0x14(%rsp),%xmm1
addps  %xmm0,%xmm1
movups 0x24(%rsp),%xmm0
movups 0x34(%rsp),%xmm2
movups 0xe4(%rsp),%xmm3
addps  %xmm1,%xmm3
movups 0xf4(%rsp),%xmm1
movups 0x104(%rsp),%xmm4
movups %xmm3,0x94(%rsp)
movups 0x64(%rsp),%xmm3
addps  %xmm0,%xmm3
addps  %xmm1,%xmm3
movups %xmm3,0xa4(%rsp)
movups 0x74(%rsp),%xmm0
addps  %xmm2,%xmm0
addps  %xmm4,%xmm0
movss  0x84(%rsp),%xmm1
addss  0x44(%rsp),%xmm1
movups %xmm0,0xb4(%rsp)
addss  0x114(%rsp),%xmm1
movss  %xmm1,0xc4(%rsp)
movss  0x88(%rsp),%xmm0
movss  0x8c(%rsp),%xmm1
addss  0x48(%rsp),%xmm0
addss  0x118(%rsp),%xmm0
addss  0x4c(%rsp),%xmm1
movss  %xmm0,0xc8(%rsp)
addss  0x11c(%rsp),%xmm1
movss  %xmm1,0xcc(%rsp)
mov    %rbx,%rdi
call   1040 <fbar@plt>
movss  0x50(%rsp),%xmm3
movaps %xmm3,0x130(%rsp)
movss  0x10(%rsp),%xmm4
movaps %xmm4,0x120(%rsp)
movss  0x68(%rsp),%xmm0
movss  0x60(%rsp),%xmm1
unpcklps %xmm0,%xmm1
movss  0x58(%rsp),%xmm2
movaps %xmm3,%xmm0
unpcklps %xmm2,%xmm0
movlhps %xmm1,%xmm0
movss  0x28(%rsp),%xmm1
movss  0x20(%rsp),%xmm2
unpcklps %xmm1,%xmm2
movss  0x18(%rsp),%xmm1
movaps %xmm4,%xmm3
unpcklps %xmm1,%xmm3
movlhps %xmm2,%xmm3
movss  0x5c(%rsp),%xmm1
movhps 0x54(%rsp),%xmm1
movss  0x64(%rsp),%xmm2
movss  0x6c(%rsp),%xmm4
movlhps %xmm2,%xmm4
shufps $0x22,%xmm4,%xmm1
movaps %xmm1,%xmm2
mulps  %xmm3,%xmm1
mulps  %xmm0,%xmm3
movss  0x1c(%rsp),%xmm4
movhps 0x14(%rsp),%xmm4
movss  0x24(%rsp),%xmm5
movss  0x2c(%rsp),%xmm6
movlhps %xmm5,%xmm6
shufps $0x22,%xmm6,%xmm4
mulps  %xmm4,%xmm2
subps  %xmm3,%xmm2
movaps %xmm2,0x90(%rsp)
mulps  %xmm0,%xmm4
addps  %xmm1,%xmm4
movaps %xmm4,0xe0(%rsp)
movss  0x84(%rsp),%xmm4
movss  0x44(%rsp),%xmm6
movsd  0x88(%rsp),%xmm7
movss  0x78(%rsp),%xmm0
unpcklpd 0x70(%rsp),%xmm0
movsd  0x48(%rsp),%xmm5
movss  0x80(%rsp),%xmm1
movaps %xmm7,%xmm2
movlhps %xmm1,%xmm2
shufps $0x22,%xmm2,%xmm0
movss  0x38(%rsp),%xmm1
unpcklpd 0x30(%rsp),%xmm1
movss  0x40(%rsp),%xmm2
movaps %xmm5,%xmm3
movlhps %xmm2,%xmm3
movss  0x7c(%rsp),%xmm2
movhps 0x74(%rsp),%xmm2
shufps $0x22,%xmm3,%xmm1
movaps %xmm7,0x140(%rsp)
movaps %xmm7,%xmm3
movaps %xmm4,0x160(%rsp)
shufps $0xc5,%xmm4,%xmm3
shufps $0x22,%xmm3,%xmm2
movaps %xmm2,%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm0,%xmm1
movss  0x3c(%rsp),%xmm4
movhps 0x34(%rsp),%xmm4
movaps %xmm5,0x150(%rsp)
movaps %xmm6,0x170(%rsp)
shufps $0xc5,%xmm6,%xmm5
shufps $0x22,%xmm5,%xmm4
mulps  %xmm4,%xmm3
subps  %xmm1,%xmm3
movaps %xmm3,0xa0(%rsp)
mulps  %xmm0,%xmm4
addps  %xmm2,%xmm4
movaps %xmm4,0xf0(%rsp)
mov    %rbx,%rdi
call   1040 <fbar@plt>
movaps 0x130(%rsp),%xmm0
addss  0x120(%rsp),%xmm0
movss  %xmm0,0x90(%rsp)
movss  %xmm0,0xe0(%rsp)
mov    0x200(%rsp),%eax
add    0x240(%rsp),%eax
mov    %eax,0x1c0(%rsp)
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movss  0x54(%rsp,%rax,1),%xmm0
addss  0x14(%rsp,%rax,1),%xmm0
movss  %xmm0,0x94(%rsp,%rax,1)
movss  %xmm0,0xe4(%rsp,%rax,1)
mov    0x204(%rsp,%rax,1),%ecx
add    0x244(%rsp,%rax,1),%ecx
mov    %ecx,0x1c4(%rsp,%rax,1)
cmp    $0x38,%rax
je     1492 <foo+0x362>
movss  0x58(%rsp,%rax,1),%xmm0
addss  0x18(%rsp,%rax,1),%xmm0
movss  %xmm0,0x98(%rsp,%rax,1)
movss  %xmm0,0xe8(%rsp,%rax,1)
mov    0x208(%rsp,%rax,1),%ecx
add    0x248(%rsp,%rax,1),%ecx
mov    %ecx,0x1c8(%rsp,%rax,1)
add    $0x8,%rax
jmp    1420 <foo+0x2f0>
lea    0x1c0(%rsp),%rbx
mov    %rbx,%rdi
call   1050 <ibar@plt>
lea    0x90(%rsp),%r14
mov    %r14,%rdi
call   1040 <fbar@plt>
lea    0xe0(%rsp),%rdi
call   1040 <fbar@plt>
movdqa 0x200(%rsp),%xmm0
movdqa 0x210(%rsp),%xmm1
paddd  0x240(%rsp),%xmm0
movdqa 0x220(%rsp),%xmm2
movdqa %xmm0,0x1c0(%rsp)
movq   0x1a0(%rsp),%xmm0
movq   0x180(%rsp),%xmm3
paddw  %xmm0,%xmm3
movq   0x1a8(%rsp),%xmm0
movq   0x188(%rsp),%xmm4
paddw  %xmm0,%xmm4
punpcklqdq %xmm4,%xmm3
movdqa %xmm3,0x280(%rsp)
paddd  0x250(%rsp),%xmm1
movdqa %xmm1,0x1d0(%rsp)
paddd  0x260(%rsp),%xmm2
movdqa %xmm2,0x1e0(%rsp)
movq   0x1b0(%rsp),%xmm0
movq   0x190(%rsp),%xmm1
paddw  %xmm0,%xmm1
movq   0x1b8(%rsp),%xmm0
movq   0x198(%rsp),%xmm2
paddw  %xmm0,%xmm2
punpcklqdq %xmm2,%xmm1
movdqa %xmm1,0x290(%rsp)
movdqa 0x230(%rsp),%xmm0
paddd  0x270(%rsp),%xmm0
movdqa %xmm0,0x1f0(%rsp)
mov    %rbx,%rdi
call   1050 <ibar@plt>
lea    0x280(%rsp),%rdi
call   1030 <sbar@plt>
movaps 0x50(%rsp),%xmm0
movaps 0x60(%rsp),%xmm1
movaps 0x70(%rsp),%xmm2
addps  0x10(%rsp),%xmm0
movaps %xmm0,0x90(%rsp)
addps  0x20(%rsp),%xmm1
addps  0x30(%rsp),%xmm2
movaps %xmm1,0xa0(%rsp)
movaps %xmm2,0xb0(%rsp)
movaps 0x160(%rsp),%xmm2
shufps $0x40,0x140(%rsp),%xmm2
movss  0x80(%rsp),%xmm0
movss  %xmm0,%xmm2
movaps 0x170(%rsp),%xmm1
shufps $0x40,0x150(%rsp),%xmm1
movss  0x40(%rsp),%xmm0
movss  %xmm0,%xmm1
addps  %xmm2,%xmm1
movaps %xmm1,0xc0(%rsp)
shufps $0xff,%xmm1,%xmm1
movss  %xmm1,0xd0(%rsp)
mov    %r14,%rdi
call   1040 <fbar@plt>
add    $0x2a8,%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 i16]
%12 = alloca [16 x i16]
%13 = alloca [16 x i16]
%14 = alloca i32
%15 = alloca 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* %3
store i32 0, i32* %16
store i32 0, i32* %16
store i32 0, i32* %14
br label %21
21: ; preds = %38, %1
%22 = load i32, i32* %14
%23 = icmp slt i32 %22, 16
br i1 %23, label %24, label %41
24: ; preds = %21
%25 = load i32, i32* %14
%26 = sext i32 %25 to i64
%27 = getelementptr inbounds [16 x i8], [16 x i8]* %17, i64 0, i64 %26
%28 = load i8, i8* %27
%29 = sext i8 %28 to i32
%30 = load i32, i32* %14
%31 = sext i32 %30 to i64
%32 = getelementptr inbounds [16 x i8], [16 x i8]* %18, i64 0, i64 %31
%33 = load i8, i8* %32
%34 = sext i8 %33 to i32
%35 = sub nsw i32 %29, %34
%36 = load i32, i32* %16
%37 = add nsw i32 %36, %35
store i32 %37, i32* %16
br label %38
38: ; preds = %24
%39 = load i32, i32* %14
%40 = add nsw i32 %39, 1
store i32 %40, i32* %14
br label %21
41: ; preds = %21
%42 = call i32 @ibar(i32* %16)
store i32 0, i32* %16
store i32 0, i32* %14
br label %43
43: ; preds = %74, %41
%44 = load i32, i32* %14
%45 = icmp slt i32 %44, 16
br i1 %45, label %46, label %77
46: ; preds = %43
store i32 0, i32* %14
br label %47
47: ; preds = %70, %46
%48 = load i32, i32* %14
%49 = icmp slt i32 %48, 16
br i1 %49, label %50, label %73
50: ; preds = %47
%51 = load i32, i32* %14
%52 = sext i32 %51 to i64
%53 = getelementptr inbounds [16 x [16 x i8]], [16 x [16 x i8]]* %19, i64 0, i64 %52
%54 = load i32, i32* %15
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds [16 x i8], [16 x i8]* %53, i64 0, i64 %55
%57 = load i8, i8* %56
%58 = sext i8 %57 to i32
%59 = load i32, i32* %14
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds [16 x [16 x i8]], [16 x [16 x i8]]* %20, i64 0, i64 %60
%62 = load i32, i32* %15
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds [16 x i8], [16 x i8]* %61, i64 0, i64 %63
%65 = load i8, i8* %64
%66 = sext i8 %65 to i32
%67 = sub nsw i32 %58, %66
%68 = load i32, i32* %16
%69 = add nsw i32 %68, %67
store i32 %69, i32* %16
br label %70
70: ; preds = %50
%71 = load i32, i32* %14
%72 = add nsw i32 %71, 1
store i32 %72, i32* %14
br label %47
73: ; preds = %47
br label %74
74: ; preds = %73
%75 = load i32, i32* %14
%76 = add nsw i32 %75, 1
store i32 %76, i32* %14
br label %43
77: ; preds = %43
%78 = call i32 @ibar(i32* %16)
store i32 0, i32* %14
br label %79
79: ; preds = %90, %77
%80 = load i32, i32* %14
%81 = icmp slt i32 %80, 16
br i1 %81, label %82, label %93
82: ; preds = %79
%83 = load i32, i32* %14
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 %84
%86 = load float, float* %85
%87 = load i32, i32* %14
%88 = sext i32 %87 to i64
%89 = getelementptr inbounds [17 x float], [17 x float]* %4, i64 0, i64 %88
store float %86, float* %89
br label %90
90: ; preds = %82
%91 = load i32, i32* %14
%92 = add nsw i32 %91, 1
store i32 %92, i32* %14
br label %79
93: ; preds = %79
%94 = getelementptr inbounds [17 x float], [17 x float]* %4, i64 0, i64 0
%95 = call i32 @fbar(float* %94)
store i32 0, i32* %14
br label %96
96: ; preds = %117, %93
%97 = load i32, i32* %14
%98 = icmp slt i32 %97, 16
br i1 %98, label %99, label %120
99: ; preds = %96
%100 = load i32, i32* %14
%101 = sext i32 %100 to i64
%102 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 %101
%103 = load float, float* %102
%104 = load i32, i32* %14
%105 = sext i32 %104 to i64
%106 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 %105
%107 = load float, float* %106
%108 = fadd float %103, %107
%109 = load i32, i32* %14
%110 = sext i32 %109 to i64
%111 = getelementptr inbounds [16 x float], [16 x float]* %7, i64 0, i64 %110
%112 = load float, float* %111
%113 = fadd float %108, %112
%114 = load i32, i32* %14
%115 = sext i32 %114 to i64
%116 = getelementptr inbounds [17 x float], [17 x float]* %4, i64 0, i64 %115
store float %113, float* %116
br label %117
117: ; preds = %99
%118 = load i32, i32* %14
%119 = add nsw i32 %118, 1
store i32 %119, i32* %14
br label %96
120: ; preds = %96
%121 = getelementptr inbounds [17 x float], [17 x float]* %4, i64 0, i64 0
%122 = call i32 @fbar(float* %121)
store i32 0, i32* %14
br label %123
123: ; preds = %182, %120
%124 = load i32, i32* %14
%125 = icmp slt i32 %124, 8
br i1 %125, label %126, label %185
126: ; preds = %123
%127 = load i32, i32* %14
%128 = mul nsw i32 2, %127
%129 = add nsw i32 %128, 1
%130 = sext i32 %129 to i64
%131 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 %130
%132 = load float, float* %131
%133 = load i32, i32* %14
%134 = mul nsw i32 2, %133
%135 = add nsw i32 %134, 1
%136 = sext i32 %135 to i64
%137 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 %136
%138 = load float, float* %137
%139 = load i32, i32* %14
%140 = mul nsw i32 2, %139
%141 = sext i32 %140 to i64
%142 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 %141
%143 = load float, float* %142
%144 = load i32, i32* %14
%145 = mul nsw i32 2, %144
%146 = sext i32 %145 to i64
%147 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 %146
%148 = load float, float* %147
%149 = fmul float %143, %148
%150 = fneg float %149
%151 = call float @llvm.fmuladd.f32(float %132, float %138, float %150)
%152 = load i32, i32* %14
%153 = sext i32 %152 to i64
%154 = getelementptr inbounds [17 x float], [17 x float]* %4, i64 0, i64 %153
store float %151, float* %154
%155 = load i32, i32* %14
%156 = mul nsw i32 2, %155
%157 = sext i32 %156 to i64
%158 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 %157
%159 = load float, float* %158
%160 = load i32, i32* %14
%161 = mul nsw i32 2, %160
%162 = add nsw i32 %161, 1
%163 = sext i32 %162 to i64
%164 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 %163
%165 = load float, float* %164
%166 = load i32, i32* %14
%167 = mul nsw i32 2, %166
%168 = add nsw i32 %167, 1
%169 = sext i32 %168 to i64
%170 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 %169
%171 = load float, float* %170
%172 = load i32, i32* %14
%173 = mul nsw i32 2, %172
%174 = sext i32 %173 to i64
%175 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 %174
%176 = load float, float* %175
%177 = fmul float %171, %176
%178 = call float @llvm.fmuladd.f32(float %159, float %165, float %177)
%179 = load i32, i32* %14
%180 = sext i32 %179 to i64
%181 = getelementptr inbounds [16 x float], [16 x float]* %7, i64 0, i64 %180
store float %178, float* %181
br label %182
182: ; preds = %126
%183 = load i32, i32* %14
%184 = add nsw i32 %183, 1
store i32 %184, i32* %14
br label %123
185: ; preds = %123
%186 = getelementptr inbounds [17 x float], [17 x float]* %4, i64 0, i64 0
%187 = call i32 @fbar(float* %186)
store i32 0, i32* %14
br label %188
188: ; preds = %228, %185
%189 = load i32, i32* %14
%190 = icmp slt i32 %189, 16
br i1 %190, label %191, label %231
191: ; preds = %188
%192 = load i32, i32* %14
%193 = sext i32 %192 to i64
%194 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 %193
%195 = load float, float* %194
%196 = load i32, i32* %14
%197 = sext i32 %196 to i64
%198 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 %197
%199 = load float, float* %198
%200 = fadd float %195, %199
%201 = load i32, i32* %14
%202 = sext i32 %201 to i64
%203 = getelementptr inbounds [17 x float], [17 x float]* %4, i64 0, i64 %202
store float %200, float* %203
%204 = load i32, i32* %14
%205 = sext i32 %204 to i64
%206 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 %205
%207 = load float, float* %206
%208 = load i32, i32* %14
%209 = sext i32 %208 to i64
%210 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 %209
%211 = load float, float* %210
%212 = fadd float %207, %211
%213 = load i32, i32* %14
%214 = sext i32 %213 to i64
%215 = getelementptr inbounds [16 x float], [16 x float]* %7, i64 0, i64 %214
store float %212, float* %215
%216 = load i32, i32* %14
%217 = sext i32 %216 to i64
%218 = getelementptr inbounds [16 x i32], [16 x i32]* %9, i64 0, i64 %217
%219 = load i32, i32* %218
%220 = load i32, i32* %14
%221 = sext i32 %220 to i64
%222 = getelementptr inbounds [16 x i32], [16 x i32]* %10, i64 0, i64 %221
%223 = load i32, i32* %222
%224 = add nsw i32 %219, %223
%225 = load i32, i32* %14
%226 = sext i32 %225 to i64
%227 = getelementptr inbounds [16 x i32], [16 x i32]* %8, i64 0, i64 %226
store i32 %224, i32* %227
br label %228
228: ; preds = %191
%229 = load i32, i32* %14
%230 = add nsw i32 %229, 1
store i32 %230, i32* %14
br label %188
231: ; preds = %188
%232 = getelementptr inbounds [16 x i32], [16 x i32]* %8, i64 0, i64 0
%233 = call i32 @ibar(i32* %232)
%234 = getelementptr inbounds [17 x float], [17 x float]* %4, i64 0, i64 0
%235 = call i32 @fbar(float* %234)
%236 = getelementptr inbounds [16 x float], [16 x float]* %7, i64 0, i64 0
%237 = call i32 @fbar(float* %236)
store i32 0, i32* %14
br label %238
238: ; preds = %269, %231
%239 = load i32, i32* %14
%240 = icmp slt i32 %239, 16
br i1 %240, label %241, label %272
241: ; preds = %238
%242 = load i32, i32* %14
%243 = sext i32 %242 to i64
%244 = getelementptr inbounds [16 x i32], [16 x i32]* %9, i64 0, i64 %243
%245 = load i32, i32* %244
%246 = load i32, i32* %14
%247 = sext i32 %246 to i64
%248 = getelementptr inbounds [16 x i32], [16 x i32]* %10, i64 0, i64 %247
%249 = load i32, i32* %248
%250 = add nsw i32 %245, %249
%251 = load i32, i32* %14
%252 = sext i32 %251 to i64
%253 = getelementptr inbounds [16 x i32], [16 x i32]* %8, i64 0, i64 %252
store i32 %250, i32* %253
%254 = load i32, i32* %14
%255 = sext i32 %254 to i64
%256 = getelementptr inbounds [16 x i16], [16 x i16]* %12, i64 0, i64 %255
%257 = load i16, i16* %256
%258 = sext i16 %257 to i32
%259 = load i32, i32* %14
%260 = sext i32 %259 to i64
%261 = getelementptr inbounds [16 x i16], [16 x i16]* %13, i64 0, i64 %260
%262 = load i16, i16* %261
%263 = sext i16 %262 to i32
%264 = add nsw i32 %258, %263
%265 = trunc i32 %264 to i16
%266 = load i32, i32* %14
%267 = sext i32 %266 to i64
%268 = getelementptr inbounds [16 x i16], [16 x i16]* %11, i64 0, i64 %267
store i16 %265, i16* %268
br label %269
269: ; preds = %241
%270 = load i32, i32* %14
%271 = add nsw i32 %270, 1
store i32 %271, i32* %14
br label %238
272: ; preds = %238
%273 = getelementptr inbounds [16 x i32], [16 x i32]* %8, i64 0, i64 0
%274 = call i32 @ibar(i32* %273)
%275 = getelementptr inbounds [16 x i16], [16 x i16]* %11, i64 0, i64 0
%276 = call i32 @sbar(i16* %275)
store i32 0, i32* %14
br label %277
277: ; preds = %306, %272
%278 = load i32, i32* %14
%279 = icmp slt i32 %278, 16
br i1 %279, label %280, label %309
280: ; preds = %277
%281 = load i32, i32* %14
%282 = sext i32 %281 to i64
%283 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 %282
%284 = load float, float* %283
%285 = load i32, i32* %14
%286 = sext i32 %285 to i64
%287 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 %286
%288 = load float, float* %287
%289 = fadd float %284, %288
%290 = load i32, i32* %14
%291 = sext i32 %290 to i64
%292 = getelementptr inbounds [17 x float], [17 x float]* %4, i64 0, i64 %291
store float %289, float* %292
%293 = load i32, i32* %14
%294 = sext i32 %293 to i64
%295 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 %294
%296 = load float, float* %295
%297 = load i32, i32* %14
%298 = sext i32 %297 to i64
%299 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 %298
%300 = load float, float* %299
%301 = fadd float %296, %300
%302 = load i32, i32* %14
%303 = add nsw i32 %302, 1
%304 = sext i32 %303 to i64
%305 = getelementptr inbounds [17 x float], [17 x float]* %4, i64 0, i64 %304
store float %301, float* %305
br label %306
306: ; preds = %280
%307 = load i32, i32* %14
%308 = add nsw i32 %307, 1
store i32 %308, i32* %14
br label %277
309: ; preds = %277
%310 = getelementptr inbounds [17 x float], [17 x float]* %4, i64 0, i64 0
%311 = call i32 @fbar(float* %310)
%312 = load i32, i32* %2
ret i32 %312
}

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