#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 *);
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];
  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++) {
    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    $0x400,%rsp
mov    %edi,-0x8(%rbp)
movl   $0x0,-0x1dc(%rbp)
movl   $0x0,-0x1dc(%rbp)
movl   $0x0,-0x1d4(%rbp)
cmpl   $0x10,-0x1d4(%rbp)
jge    1199 <foo+0x79>
movslq -0x1d4(%rbp),%rax
movsbl -0x1f0(%rbp,%rax,1),%eax
ff
movslq -0x1d4(%rbp),%rcx
movsbl -0x200(%rbp,%rcx,1),%ecx
ff
sub    %ecx,%eax
add    -0x1dc(%rbp),%eax
mov    %eax,-0x1dc(%rbp)
mov    -0x1d4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1d4(%rbp)
jmp    114c <foo+0x2c>
lea    -0x1dc(%rbp),%rdi
call   1040 <ibar@plt>
movl   $0x0,-0x1dc(%rbp)
movl   $0x0,-0x1d4(%rbp)
cmpl   $0x10,-0x1d4(%rbp)
jge    1258 <foo+0x138>
movl   $0x0,-0x1d4(%rbp)
cmpl   $0x10,-0x1d4(%rbp)
jge    123f <foo+0x11f>
movslq -0x1d4(%rbp),%rcx
lea    -0x300(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x1d8(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
movslq -0x1d4(%rbp),%rdx
lea    -0x400(%rbp),%rcx
shl    $0x4,%rdx
add    %rdx,%rcx
movslq -0x1d8(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
sub    %ecx,%eax
add    -0x1dc(%rbp),%eax
mov    %eax,-0x1dc(%rbp)
mov    -0x1d4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1d4(%rbp)
jmp    11d0 <foo+0xb0>
jmp    1244 <foo+0x124>
mov    -0x1d4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1d4(%rbp)
jmp    11b9 <foo+0x99>
lea    -0x1dc(%rbp),%rdi
call   1040 <ibar@plt>
movl   $0x0,-0x1d4(%rbp)
cmpl   $0x10,-0x1d4(%rbp)
jge    12ac <foo+0x18c>
movslq -0x1d4(%rbp),%rax
movss  -0x90(%rbp,%rax,4),%xmm0
ff ff
movslq -0x1d4(%rbp),%rax
movss  %xmm0,-0x50(%rbp,%rax,4)
mov    -0x1d4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1d4(%rbp)
jmp    126e <foo+0x14e>
lea    -0x50(%rbp),%rdi
call   1030 <fbar@plt>
movl   $0x0,-0x1d4(%rbp)
cmpl   $0x10,-0x1d4(%rbp)
jge    131d <foo+0x1fd>
movslq -0x1d4(%rbp),%rax
movss  -0x90(%rbp,%rax,4),%xmm0
ff ff
movslq -0x1d4(%rbp),%rax
addss  -0xd0(%rbp,%rax,4),%xmm0
ff ff
movslq -0x1d4(%rbp),%rax
addss  -0x110(%rbp,%rax,4),%xmm0
ff ff
movslq -0x1d4(%rbp),%rax
movss  %xmm0,-0x50(%rbp,%rax,4)
mov    -0x1d4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1d4(%rbp)
jmp    12bf <foo+0x19f>
lea    -0x50(%rbp),%rdi
call   1030 <fbar@plt>
movl   $0x0,-0x1d4(%rbp)
cmpl   $0x8,-0x1d4(%rbp)
jge    1437 <foo+0x317>
mov    -0x1d4(%rbp),%eax
shl    $0x1,%eax
add    $0x1,%eax
cltq
movss  -0x90(%rbp,%rax,4),%xmm0
ff ff
mov    -0x1d4(%rbp),%eax
shl    $0x1,%eax
add    $0x1,%eax
cltq
movss  -0xd0(%rbp,%rax,4),%xmm2
ff ff
mov    -0x1d4(%rbp),%eax
shl    $0x1,%eax
cltq
movss  -0x90(%rbp,%rax,4),%xmm1
ff ff
mov    -0x1d4(%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 -0x1d4(%rbp),%rax
movss  %xmm0,-0x50(%rbp,%rax,4)
mov    -0x1d4(%rbp),%eax
shl    $0x1,%eax
cltq
movss  -0x90(%rbp,%rax,4),%xmm0
ff ff
mov    -0x1d4(%rbp),%eax
shl    $0x1,%eax
add    $0x1,%eax
cltq
movss  -0xd0(%rbp,%rax,4),%xmm2
ff ff
mov    -0x1d4(%rbp),%eax
shl    $0x1,%eax
add    $0x1,%eax
cltq
movss  -0x90(%rbp,%rax,4),%xmm1
ff ff
mov    -0x1d4(%rbp),%eax
shl    $0x1,%eax
cltq
mulss  -0xd0(%rbp,%rax,4),%xmm1
ff ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq -0x1d4(%rbp),%rax
movss  %xmm0,-0x110(%rbp,%rax,4)
ff ff
mov    -0x1d4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1d4(%rbp)
jmp    1330 <foo+0x210>
lea    -0x50(%rbp),%rdi
call   1030 <fbar@plt>
movl   $0x0,-0x1d4(%rbp)
cmpl   $0x10,-0x1d4(%rbp)
jge    14f2 <foo+0x3d2>
movslq -0x1d4(%rbp),%rax
movss  -0x90(%rbp,%rax,4),%xmm0
ff ff
movslq -0x1d4(%rbp),%rax
addss  -0xd0(%rbp,%rax,4),%xmm0
ff ff
movslq -0x1d4(%rbp),%rax
movss  %xmm0,-0x50(%rbp,%rax,4)
movslq -0x1d4(%rbp),%rax
movss  -0x90(%rbp,%rax,4),%xmm0
ff ff
movslq -0x1d4(%rbp),%rax
addss  -0xd0(%rbp,%rax,4),%xmm0
ff ff
movslq -0x1d4(%rbp),%rax
movss  %xmm0,-0x110(%rbp,%rax,4)
ff ff
movslq -0x1d4(%rbp),%rax
mov    -0x190(%rbp,%rax,4),%ecx
movslq -0x1d4(%rbp),%rax
add    -0x1d0(%rbp,%rax,4),%ecx
movslq -0x1d4(%rbp),%rax
mov    %ecx,-0x150(%rbp,%rax,4)
mov    -0x1d4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1d4(%rbp)
jmp    144a <foo+0x32a>
lea    -0x150(%rbp),%rdi
call   1040 <ibar@plt>
lea    -0x50(%rbp),%rdi
call   1030 <fbar@plt>
lea    -0x110(%rbp),%rdi
call   1030 <fbar@plt>
movl   $0x0,-0x1d4(%rbp)
cmpl   $0x10,-0x1d4(%rbp)
jge    159c <foo+0x47c>
movslq -0x1d4(%rbp),%rax
movss  -0x90(%rbp,%rax,4),%xmm0
ff ff
movslq -0x1d4(%rbp),%rax
addss  -0xd0(%rbp,%rax,4),%xmm0
ff ff
movslq -0x1d4(%rbp),%rax
movss  %xmm0,-0x50(%rbp,%rax,4)
movslq -0x1d4(%rbp),%rax
movss  -0x90(%rbp,%rax,4),%xmm0
ff ff
movslq -0x1d4(%rbp),%rax
addss  -0xd0(%rbp,%rax,4),%xmm0
ff ff
mov    -0x1d4(%rbp),%eax
add    $0x1,%eax
cltq
movss  %xmm0,-0x50(%rbp,%rax,4)
mov    -0x1d4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1d4(%rbp)
jmp    151d <foo+0x3fd>
lea    -0x50(%rbp),%rdi
call   1030 <fbar@plt>
mov    -0x4(%rbp),%eax
add    $0x400,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<foo>:
push   %rbx
sub    $0x240,%rsp
movl   $0x0,0xc(%rsp)
lea    0xc(%rsp),%rbx
mov    %rbx,%rdi
call   1040 <ibar@plt>
movl   $0x0,0xc(%rsp)
mov    %rbx,%rdi
call   1040 <ibar@plt>
lea    0x90(%rsp),%rbx
mov    %rbx,%rdi
call   1030 <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   1030 <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   1030 <fbar@plt>
movaps 0x130(%rsp),%xmm0
addss  0x120(%rsp),%xmm0
movss  %xmm0,0x90(%rsp)
movss  %xmm0,0xe0(%rsp)
mov    0x1c0(%rsp),%eax
add    0x200(%rsp),%eax
mov    %eax,0x180(%rsp)
xor    %eax,%eax
nopl   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    0x1c4(%rsp,%rax,1),%ecx
add    0x204(%rsp,%rax,1),%ecx
mov    %ecx,0x184(%rsp,%rax,1)
cmp    $0x38,%rax
je     1482 <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    0x1c8(%rsp,%rax,1),%ecx
add    0x208(%rsp,%rax,1),%ecx
mov    %ecx,0x188(%rsp,%rax,1)
add    $0x8,%rax
jmp    1410 <foo+0x2f0>
lea    0x180(%rsp),%rdi
call   1040 <ibar@plt>
lea    0x90(%rsp),%rbx
mov    %rbx,%rdi
call   1030 <fbar@plt>
lea    0xe0(%rsp),%rdi
call   1030 <fbar@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    %rbx,%rdi
call   1030 <fbar@plt>
add    $0x240,%rsp
pop    %rbx
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 i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca [16 x i8]
%15 = alloca [16 x i8]
%16 = alloca [16 x [16 x i8]]
%17 = alloca [16 x [16 x i8]]
store i32 %0, i32* %3
store i32 0, i32* %13
store i32 0, i32* %13
store i32 0, i32* %11
br label %18
18: ; preds = %35, %1
%19 = load i32, i32* %11
%20 = icmp slt i32 %19, 16
br i1 %20, label %21, label %38
21: ; preds = %18
%22 = load i32, i32* %11
%23 = sext i32 %22 to i64
%24 = getelementptr inbounds [16 x i8], [16 x i8]* %14, i64 0, i64 %23
%25 = load i8, i8* %24
%26 = sext i8 %25 to i32
%27 = load i32, i32* %11
%28 = sext i32 %27 to i64
%29 = getelementptr inbounds [16 x i8], [16 x i8]* %15, i64 0, i64 %28
%30 = load i8, i8* %29
%31 = sext i8 %30 to i32
%32 = sub nsw i32 %26, %31
%33 = load i32, i32* %13
%34 = add nsw i32 %33, %32
store i32 %34, i32* %13
br label %35
35: ; preds = %21
%36 = load i32, i32* %11
%37 = add nsw i32 %36, 1
store i32 %37, i32* %11
br label %18
38: ; preds = %18
%39 = call i32 @ibar(i32* %13)
store i32 0, i32* %13
store i32 0, i32* %11
br label %40
40: ; preds = %71, %38
%41 = load i32, i32* %11
%42 = icmp slt i32 %41, 16
br i1 %42, label %43, label %74
43: ; preds = %40
store i32 0, i32* %11
br label %44
44: ; preds = %67, %43
%45 = load i32, i32* %11
%46 = icmp slt i32 %45, 16
br i1 %46, label %47, label %70
47: ; preds = %44
%48 = load i32, i32* %11
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds [16 x [16 x i8]], [16 x [16 x i8]]* %16, i64 0, i64 %49
%51 = load i32, i32* %12
%52 = sext i32 %51 to i64
%53 = getelementptr inbounds [16 x i8], [16 x i8]* %50, i64 0, i64 %52
%54 = load i8, i8* %53
%55 = sext i8 %54 to i32
%56 = load i32, i32* %11
%57 = sext i32 %56 to i64
%58 = getelementptr inbounds [16 x [16 x i8]], [16 x [16 x i8]]* %17, i64 0, i64 %57
%59 = load i32, i32* %12
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds [16 x i8], [16 x i8]* %58, i64 0, i64 %60
%62 = load i8, i8* %61
%63 = sext i8 %62 to i32
%64 = sub nsw i32 %55, %63
%65 = load i32, i32* %13
%66 = add nsw i32 %65, %64
store i32 %66, i32* %13
br label %67
67: ; preds = %47
%68 = load i32, i32* %11
%69 = add nsw i32 %68, 1
store i32 %69, i32* %11
br label %44
70: ; preds = %44
br label %71
71: ; preds = %70
%72 = load i32, i32* %11
%73 = add nsw i32 %72, 1
store i32 %73, i32* %11
br label %40
74: ; preds = %40
%75 = call i32 @ibar(i32* %13)
store i32 0, i32* %11
br label %76
76: ; preds = %87, %74
%77 = load i32, i32* %11
%78 = icmp slt i32 %77, 16
br i1 %78, label %79, label %90
79: ; preds = %76
%80 = load i32, i32* %11
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 %81
%83 = load float, float* %82
%84 = load i32, i32* %11
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds [17 x float], [17 x float]* %4, i64 0, i64 %85
store float %83, float* %86
br label %87
87: ; preds = %79
%88 = load i32, i32* %11
%89 = add nsw i32 %88, 1
store i32 %89, i32* %11
br label %76
90: ; preds = %76
%91 = getelementptr inbounds [17 x float], [17 x float]* %4, i64 0, i64 0
%92 = call i32 @fbar(float* %91)
store i32 0, i32* %11
br label %93
93: ; preds = %114, %90
%94 = load i32, i32* %11
%95 = icmp slt i32 %94, 16
br i1 %95, label %96, label %117
96: ; preds = %93
%97 = load i32, i32* %11
%98 = sext i32 %97 to i64
%99 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 %98
%100 = load float, float* %99
%101 = load i32, i32* %11
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 %102
%104 = load float, float* %103
%105 = fadd float %100, %104
%106 = load i32, i32* %11
%107 = sext i32 %106 to i64
%108 = getelementptr inbounds [16 x float], [16 x float]* %7, i64 0, i64 %107
%109 = load float, float* %108
%110 = fadd float %105, %109
%111 = load i32, i32* %11
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds [17 x float], [17 x float]* %4, i64 0, i64 %112
store float %110, float* %113
br label %114
114: ; preds = %96
%115 = load i32, i32* %11
%116 = add nsw i32 %115, 1
store i32 %116, i32* %11
br label %93
117: ; preds = %93
%118 = getelementptr inbounds [17 x float], [17 x float]* %4, i64 0, i64 0
%119 = call i32 @fbar(float* %118)
store i32 0, i32* %11
br label %120
120: ; preds = %179, %117
%121 = load i32, i32* %11
%122 = icmp slt i32 %121, 8
br i1 %122, label %123, label %182
123: ; preds = %120
%124 = load i32, i32* %11
%125 = mul nsw i32 2, %124
%126 = add nsw i32 %125, 1
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 %127
%129 = load float, float* %128
%130 = load i32, i32* %11
%131 = mul nsw i32 2, %130
%132 = add nsw i32 %131, 1
%133 = sext i32 %132 to i64
%134 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 %133
%135 = load float, float* %134
%136 = load i32, i32* %11
%137 = mul nsw i32 2, %136
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 %138
%140 = load float, float* %139
%141 = load i32, i32* %11
%142 = mul nsw i32 2, %141
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 %143
%145 = load float, float* %144
%146 = fmul float %140, %145
%147 = fneg float %146
%148 = call float @llvm.fmuladd.f32(float %129, float %135, float %147)
%149 = load i32, i32* %11
%150 = sext i32 %149 to i64
%151 = getelementptr inbounds [17 x float], [17 x float]* %4, i64 0, i64 %150
store float %148, float* %151
%152 = load i32, i32* %11
%153 = mul nsw i32 2, %152
%154 = sext i32 %153 to i64
%155 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 %154
%156 = load float, float* %155
%157 = load i32, i32* %11
%158 = mul nsw i32 2, %157
%159 = add nsw i32 %158, 1
%160 = sext i32 %159 to i64
%161 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 %160
%162 = load float, float* %161
%163 = load i32, i32* %11
%164 = mul nsw i32 2, %163
%165 = add nsw i32 %164, 1
%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* %11
%170 = mul nsw i32 2, %169
%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 = fmul float %168, %173
%175 = call float @llvm.fmuladd.f32(float %156, float %162, float %174)
%176 = load i32, i32* %11
%177 = sext i32 %176 to i64
%178 = getelementptr inbounds [16 x float], [16 x float]* %7, i64 0, i64 %177
store float %175, float* %178
br label %179
179: ; preds = %123
%180 = load i32, i32* %11
%181 = add nsw i32 %180, 1
store i32 %181, i32* %11
br label %120
182: ; preds = %120
%183 = getelementptr inbounds [17 x float], [17 x float]* %4, i64 0, i64 0
%184 = call i32 @fbar(float* %183)
store i32 0, i32* %11
br label %185
185: ; preds = %225, %182
%186 = load i32, i32* %11
%187 = icmp slt i32 %186, 16
br i1 %187, label %188, label %228
188: ; preds = %185
%189 = load i32, i32* %11
%190 = sext i32 %189 to i64
%191 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 %190
%192 = load float, float* %191
%193 = load i32, i32* %11
%194 = sext i32 %193 to i64
%195 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 %194
%196 = load float, float* %195
%197 = fadd float %192, %196
%198 = load i32, i32* %11
%199 = sext i32 %198 to i64
%200 = getelementptr inbounds [17 x float], [17 x float]* %4, i64 0, i64 %199
store float %197, float* %200
%201 = load i32, i32* %11
%202 = sext i32 %201 to i64
%203 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 %202
%204 = load float, float* %203
%205 = load i32, i32* %11
%206 = sext i32 %205 to i64
%207 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 %206
%208 = load float, float* %207
%209 = fadd float %204, %208
%210 = load i32, i32* %11
%211 = sext i32 %210 to i64
%212 = getelementptr inbounds [16 x float], [16 x float]* %7, i64 0, i64 %211
store float %209, float* %212
%213 = load i32, i32* %11
%214 = sext i32 %213 to i64
%215 = getelementptr inbounds [16 x i32], [16 x i32]* %9, i64 0, i64 %214
%216 = load i32, i32* %215
%217 = load i32, i32* %11
%218 = sext i32 %217 to i64
%219 = getelementptr inbounds [16 x i32], [16 x i32]* %10, i64 0, i64 %218
%220 = load i32, i32* %219
%221 = add nsw i32 %216, %220
%222 = load i32, i32* %11
%223 = sext i32 %222 to i64
%224 = getelementptr inbounds [16 x i32], [16 x i32]* %8, i64 0, i64 %223
store i32 %221, i32* %224
br label %225
225: ; preds = %188
%226 = load i32, i32* %11
%227 = add nsw i32 %226, 1
store i32 %227, i32* %11
br label %185
228: ; preds = %185
%229 = getelementptr inbounds [16 x i32], [16 x i32]* %8, i64 0, i64 0
%230 = call i32 @ibar(i32* %229)
%231 = getelementptr inbounds [17 x float], [17 x float]* %4, i64 0, i64 0
%232 = call i32 @fbar(float* %231)
%233 = getelementptr inbounds [16 x float], [16 x float]* %7, i64 0, i64 0
%234 = call i32 @fbar(float* %233)
store i32 0, i32* %11
br label %235
235: ; preds = %264, %228
%236 = load i32, i32* %11
%237 = icmp slt i32 %236, 16
br i1 %237, label %238, label %267
238: ; preds = %235
%239 = load i32, i32* %11
%240 = sext i32 %239 to i64
%241 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 %240
%242 = load float, float* %241
%243 = load i32, i32* %11
%244 = sext i32 %243 to i64
%245 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 %244
%246 = load float, float* %245
%247 = fadd float %242, %246
%248 = load i32, i32* %11
%249 = sext i32 %248 to i64
%250 = getelementptr inbounds [17 x float], [17 x float]* %4, i64 0, i64 %249
store float %247, float* %250
%251 = load i32, i32* %11
%252 = sext i32 %251 to i64
%253 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 %252
%254 = load float, float* %253
%255 = load i32, i32* %11
%256 = sext i32 %255 to i64
%257 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 %256
%258 = load float, float* %257
%259 = fadd float %254, %258
%260 = load i32, i32* %11
%261 = add nsw i32 %260, 1
%262 = sext i32 %261 to i64
%263 = getelementptr inbounds [17 x float], [17 x float]* %4, i64 0, i64 %262
store float %259, float* %263
br label %264
264: ; preds = %238
%265 = load i32, i32* %11
%266 = add nsw i32 %265, 1
store i32 %266, i32* %11
br label %235
267: ; preds = %235
%268 = getelementptr inbounds [17 x float], [17 x float]* %4, i64 0, i64 0
%269 = call i32 @fbar(float* %268)
%270 = load i32, i32* %2
ret i32 %270
}

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