#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 */
void functionDependTest1(float *a, float *d, const float *b, const float *c,
                         const float *e, size_t size) {
  if (a == NULL || b == NULL || c == NULL || d == NULL || e == NULL ||
      size == 0)
    return;
  int i;
  for (i = 1; i < size; ++i) {
    d[i] = e[i] - a[i];
    a[i] = b[i] + c[i];
  }
}


x86 assembly (clang, -O0):
<functionDependTest1>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
cmpq   $0x0,-0x8(%rbp)
je     115e <functionDependTest1+0x5e>
cmpq   $0x0,-0x18(%rbp)
je     115e <functionDependTest1+0x5e>
cmpq   $0x0,-0x20(%rbp)
je     115e <functionDependTest1+0x5e>
cmpq   $0x0,-0x10(%rbp)
je     115e <functionDependTest1+0x5e>
cmpq   $0x0,-0x28(%rbp)
je     115e <functionDependTest1+0x5e>
cmpq   $0x0,-0x30(%rbp)
jne    1163 <functionDependTest1+0x63>
jmp    11d4 <functionDependTest1+0xd4>
movl   $0x1,-0x34(%rbp)
movslq -0x34(%rbp),%rax
cmp    -0x30(%rbp),%rax
jae    11d4 <functionDependTest1+0xd4>
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    116a <functionDependTest1+0x6a>
pop    %rbp
ret

x86 assembly (clang, -O2):
<functionDependTest1>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
cmp    $0x2,%r9
jb     13c8 <functionDependTest1+0x2c8>
test   %r8,%r8
je     13c8 <functionDependTest1+0x2c8>
test   %rsi,%rsi
je     13c8 <functionDependTest1+0x2c8>
test   %rdi,%rdi
je     13c8 <functionDependTest1+0x2c8>
test   %rdx,%rdx
je     13c8 <functionDependTest1+0x2c8>
test   %rcx,%rcx
je     13c8 <functionDependTest1+0x2c8>
lea    -0x1(%r9),%rax
mov    $0x1,%r11d
cmp    $0x4,%rax
jae    1210 <functionDependTest1+0x110>
mov    %r11,%rax
not    %rax
test   $0x1,%r9b
jne    1189 <functionDependTest1+0x89>
movss  (%r8,%r11,4),%xmm0
subss  (%rdi,%r11,4),%xmm0
movss  %xmm0,(%rsi,%r11,4)
movss  (%rdx,%r11,4),%xmm0
addss  (%rcx,%r11,4),%xmm0
movss  %xmm0,(%rdi,%r11,4)
add    $0x1,%r11
add    %r9,%rax
je     13c8 <functionDependTest1+0x2c8>
sub    %r11,%r9
lea    (%rcx,%r11,4),%rax
add    $0x4,%rax
lea    0x4(%rdx,%r11,4),%rcx
lea    (%rsi,%r11,4),%rdx
add    $0x4,%rdx
lea    (%rdi,%r11,4),%rsi
add    $0x4,%rsi
lea    (%r8,%r11,4),%rdi
add    $0x4,%rdi
xor    %ebp,%ebp
nopl   0x0(%rax)
movss  -0x4(%rdi,%rbp,4),%xmm0
subss  -0x4(%rsi,%rbp,4),%xmm0
movss  %xmm0,-0x4(%rdx,%rbp,4)
movss  -0x4(%rcx,%rbp,4),%xmm0
addss  -0x4(%rax,%rbp,4),%xmm0
movss  %xmm0,-0x4(%rsi,%rbp,4)
movss  (%rdi,%rbp,4),%xmm0
subss  (%rsi,%rbp,4),%xmm0
movss  %xmm0,(%rdx,%rbp,4)
movss  (%rcx,%rbp,4),%xmm0
addss  (%rax,%rbp,4),%xmm0
movss  %xmm0,(%rsi,%rbp,4)
add    $0x2,%rbp
cmp    %rbp,%r9
jne    11c0 <functionDependTest1+0xc0>
jmp    13c8 <functionDependTest1+0x2c8>
mov    %rax,-0x18(%rsp)
lea    0x4(%rsi),%rbp
lea    (%rsi,%r9,4),%r12
lea    0x4(%rdi),%rbx
lea    (%rdi,%r9,4),%r14
lea    0x4(%r8),%rax
mov    %rax,-0x10(%rsp)
lea    (%r8,%r9,4),%r15
lea    0x4(%rdx),%r10
mov    %r10,-0x20(%rsp)
lea    (%rdx,%r9,4),%rax
lea    (%rcx,%r9,4),%r13
mov    %r13,-0x8(%rsp)
cmp    %r14,%rbp
setb   -0x21(%rsp)
cmp    %r12,%rbx
setb   -0x22(%rsp)
cmp    %r15,%rbp
setb   -0x23(%rsp)
mov    -0x10(%rsp),%r13
cmp    %r12,%r13
setb   -0x24(%rsp)
cmp    %rax,%rbp
setb   -0x25(%rsp)
cmp    %r12,%r10
setb   -0x26(%rsp)
mov    -0x8(%rsp),%r10
cmp    %r10,%rbp
lea    0x4(%rcx),%rbp
setb   -0x27(%rsp)
cmp    %r12,%rbp
setb   -0x28(%rsp)
cmp    %r15,%rbx
setb   %r12b
cmp    %r14,%r13
setb   %r15b
cmp    %rax,%rbx
setb   %r13b
cmp    %r14,-0x20(%rsp)
setb   -0x20(%rsp)
cmp    %r10,%rbx
setb   %bl
cmp    %r14,%rbp
setb   %r10b
mov    -0x22(%rsp),%al
test   %al,-0x21(%rsp)
jne    1155 <functionDependTest1+0x55>
mov    -0x24(%rsp),%al
and    %al,-0x23(%rsp)
jne    1155 <functionDependTest1+0x55>
mov    -0x26(%rsp),%al
and    %al,-0x25(%rsp)
jne    1155 <functionDependTest1+0x55>
mov    -0x28(%rsp),%al
and    %al,-0x27(%rsp)
jne    1155 <functionDependTest1+0x55>
and    %r15b,%r12b
jne    1155 <functionDependTest1+0x55>
and    -0x20(%rsp),%r13b
jne    1155 <functionDependTest1+0x55>
and    %r10b,%bl
jne    1155 <functionDependTest1+0x55>
mov    -0x18(%rsp),%rbp
mov    %rbp,%r11
and    $0xfffffffffffffffc,%r11
lea    -0x4(%r11),%rax
mov    %rax,%r14
shr    $0x2,%r14
add    $0x1,%r14
test   %rax,%rax
je     13dc <functionDependTest1+0x2dc>
mov    %r14,%rbx
and    $0xfffffffffffffffe,%rbx
mov    $0x1,%eax
nopw   0x0(%rax,%rax,1)
movups (%r8,%rax,4),%xmm0
movups (%rdi,%rax,4),%xmm1
subps  %xmm1,%xmm0
movups %xmm0,(%rsi,%rax,4)
movups (%rdx,%rax,4),%xmm0
movups (%rcx,%rax,4),%xmm1
addps  %xmm0,%xmm1
movups %xmm1,(%rdi,%rax,4)
movups 0x10(%r8,%rax,4),%xmm0
movups 0x10(%rdi,%rax,4),%xmm1
subps  %xmm1,%xmm0
movups %xmm0,0x10(%rsi,%rax,4)
movups 0x10(%rdx,%rax,4),%xmm0
movups 0x10(%rcx,%rax,4),%xmm1
addps  %xmm0,%xmm1
movups %xmm1,0x10(%rdi,%rax,4)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rbx
jne    1350 <functionDependTest1+0x250>
test   $0x1,%r14b
je     13c3 <functionDependTest1+0x2c3>
movups (%r8,%rax,4),%xmm0
movups (%rdi,%rax,4),%xmm1
subps  %xmm1,%xmm0
movups %xmm0,(%rsi,%rax,4)
movups (%rdx,%rax,4),%xmm0
movups (%rcx,%rax,4),%xmm1
addps  %xmm0,%xmm1
movups %xmm1,(%rdi,%rax,4)
cmp    %r11,%rbp
jne    13d3 <functionDependTest1+0x2d3>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
or     $0x1,%r11
jmp    1155 <functionDependTest1+0x55>
mov    $0x1,%eax
test   $0x1,%r14b
jne    13a4 <functionDependTest1+0x2a4>
jmp    13c3 <functionDependTest1+0x2c3>

LLVM IR (-O0):
define void @functionDependTest1(float* %0, float* %1, float* %2, float* %3, float* %4, i64 %5) {
%7 = alloca float*
%8 = alloca float*
%9 = alloca float*
%10 = alloca float*
%11 = alloca float*
%12 = alloca i64
%13 = alloca i32
store float* %0, float** %7
store float* %1, float** %8
store float* %2, float** %9
store float* %3, float** %10
store float* %4, float** %11
store i64 %5, i64* %12
%14 = load float*, float** %7
%15 = icmp eq float* %14, null
br i1 %15, label %31, label %16
16: ; preds = %6
%17 = load float*, float** %9
%18 = icmp eq float* %17, null
br i1 %18, label %31, label %19
19: ; preds = %16
%20 = load float*, float** %10
%21 = icmp eq float* %20, null
br i1 %21, label %31, label %22
22: ; preds = %19
%23 = load float*, float** %8
%24 = icmp eq float* %23, null
br i1 %24, label %31, label %25
25: ; preds = %22
%26 = load float*, float** %11
%27 = icmp eq float* %26, null
br i1 %27, label %31, label %28
28: ; preds = %25
%29 = load i64, i64* %12
%30 = icmp eq i64 %29, 0
br i1 %30, label %31, label %32
31: ; preds = %28, %25, %22, %19, %16, %6
br label %72
32: ; preds = %28
store i32 1, i32* %13
br label %33
33: ; preds = %69, %32
%34 = load i32, i32* %13
%35 = sext i32 %34 to i64
%36 = load i64, i64* %12
%37 = icmp ult i64 %35, %36
br i1 %37, label %38, label %72
38: ; preds = %33
%39 = load float*, float** %11
%40 = load i32, i32* %13
%41 = sext i32 %40 to i64
%42 = getelementptr inbounds float, float* %39, i64 %41
%43 = load float, float* %42
%44 = load float*, float** %7
%45 = load i32, i32* %13
%46 = sext i32 %45 to i64
%47 = getelementptr inbounds float, float* %44, i64 %46
%48 = load float, float* %47
%49 = fsub float %43, %48
%50 = load float*, float** %8
%51 = load i32, i32* %13
%52 = sext i32 %51 to i64
%53 = getelementptr inbounds float, float* %50, i64 %52
store float %49, float* %53
%54 = load float*, float** %9
%55 = load i32, i32* %13
%56 = sext i32 %55 to i64
%57 = getelementptr inbounds float, float* %54, i64 %56
%58 = load float, float* %57
%59 = load float*, float** %10
%60 = load i32, i32* %13
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds float, float* %59, i64 %61
%63 = load float, float* %62
%64 = fadd float %58, %63
%65 = load float*, float** %7
%66 = load i32, i32* %13
%67 = sext i32 %66 to i64
%68 = getelementptr inbounds float, float* %65, i64 %67
store float %64, float* %68
br label %69
69: ; preds = %38
%70 = load i32, i32* %13
%71 = add nsw i32 %70, 1
store i32 %71, i32* %13
br label %33
72: ; preds = %31, %33
ret void
}

LLVM IR (-O2):
define void @functionDependTest1(float* %0, float* writeonly %1, float* %2, float* %3, float* %4, i64 %5) {
%7 = icmp eq float* %0, null
%8 = icmp eq float* %2, null
%9 = or i1 %7, %8
%10 = icmp eq float* %3, null
%11 = or i1 %9, %10
%12 = icmp eq float* %1, null
%13 = or i1 %12, %11
%14 = icmp eq float* %4, null
%15 = or i1 %14, %13
%16 = icmp ult i64 %5, 2
%17 = or i1 %16, %15
br i1 %17, label %185, label %18
18: ; preds = %6
%19 = add i64 %5, -1
%20 = icmp ult i64 %19, 4
br i1 %20, label %136, label %21
21: ; preds = %18
%22 = getelementptr float, float* %1, i64 1
%23 = getelementptr float, float* %1, i64 %5
%24 = getelementptr float, float* %0, i64 1
%25 = getelementptr float, float* %0, i64 %5
%26 = getelementptr float, float* %4, i64 1
%27 = getelementptr float, float* %4, i64 %5
%28 = getelementptr float, float* %2, i64 1
%29 = getelementptr float, float* %2, i64 %5
%30 = getelementptr float, float* %3, i64 1
%31 = getelementptr float, float* %3, i64 %5
%32 = icmp ult float* %22, %25
%33 = icmp ult float* %24, %23
%34 = and i1 %32, %33
%35 = icmp ult float* %22, %27
%36 = icmp ult float* %26, %23
%37 = and i1 %35, %36
%38 = or i1 %34, %37
%39 = icmp ult float* %22, %29
%40 = icmp ult float* %28, %23
%41 = and i1 %39, %40
%42 = or i1 %38, %41
%43 = icmp ult float* %22, %31
%44 = icmp ult float* %30, %23
%45 = and i1 %43, %44
%46 = or i1 %42, %45
%47 = icmp ult float* %24, %27
%48 = icmp ult float* %26, %25
%49 = and i1 %47, %48
%50 = or i1 %46, %49
%51 = icmp ult float* %24, %29
%52 = icmp ult float* %28, %25
%53 = and i1 %51, %52
%54 = or i1 %50, %53
%55 = icmp ult float* %24, %31
%56 = icmp ult float* %30, %25
%57 = and i1 %55, %56
%58 = or i1 %54, %57
br i1 %58, label %136, label %59
59: ; preds = %21
%60 = and i64 %19, -4
%61 = or i64 %60, 1
%62 = add i64 %60, -4
%63 = lshr exact i64 %62, 2
%64 = add nuw nsw i64 %63, 1
%65 = and i64 %64, 1
%66 = icmp eq i64 %62, 0
br i1 %66, label %113, label %67
67: ; preds = %59
%68 = and i64 %64, 9223372036854775806
br label %69
69: ; preds = %69, %67
%70 = phi i64 [ 0, %67 ], [ %108, %69 ]
%71 = phi i64 [ 0, %67 ], [ %109, %69 ]
%72 = or i64 %70, 1
%73 = getelementptr inbounds float, float* %4, i64 %72
%74 = bitcast float* %73 to <4 x float>*
%75 = load <4 x float>, <4 x float>* %74
%76 = getelementptr inbounds float, float* %0, i64 %72
%77 = bitcast float* %76 to <4 x float>*
%78 = load <4 x float>, <4 x float>* %77
%79 = fsub <4 x float> %75, %78
%80 = getelementptr inbounds float, float* %1, i64 %72
%81 = bitcast float* %80 to <4 x float>*
store <4 x float> %79, <4 x float>* %81
%82 = getelementptr inbounds float, float* %2, i64 %72
%83 = bitcast float* %82 to <4 x float>*
%84 = load <4 x float>, <4 x float>* %83
%85 = getelementptr inbounds float, float* %3, i64 %72
%86 = bitcast float* %85 to <4 x float>*
%87 = load <4 x float>, <4 x float>* %86
%88 = fadd <4 x float> %84, %87
%89 = bitcast float* %76 to <4 x float>*
store <4 x float> %88, <4 x float>* %89
%90 = or i64 %70, 5
%91 = getelementptr inbounds float, float* %4, i64 %90
%92 = bitcast float* %91 to <4 x float>*
%93 = load <4 x float>, <4 x float>* %92
%94 = getelementptr inbounds float, float* %0, i64 %90
%95 = bitcast float* %94 to <4 x float>*
%96 = load <4 x float>, <4 x float>* %95
%97 = fsub <4 x float> %93, %96
%98 = getelementptr inbounds float, float* %1, i64 %90
%99 = bitcast float* %98 to <4 x float>*
store <4 x float> %97, <4 x float>* %99
%100 = getelementptr inbounds float, float* %2, i64 %90
%101 = bitcast float* %100 to <4 x float>*
%102 = load <4 x float>, <4 x float>* %101
%103 = getelementptr inbounds float, float* %3, i64 %90
%104 = bitcast float* %103 to <4 x float>*
%105 = load <4 x float>, <4 x float>* %104
%106 = fadd <4 x float> %102, %105
%107 = bitcast float* %94 to <4 x float>*
store <4 x float> %106, <4 x float>* %107
%108 = add nuw i64 %70, 8
%109 = add i64 %71, 2
%110 = icmp eq i64 %109, %68
br i1 %110, label %111, label %69
111: ; preds = %69
%112 = or i64 %108, 1
br label %113
113: ; preds = %111, %59
%114 = phi i64 [ 1, %59 ], [ %112, %111 ]
%115 = icmp eq i64 %65, 0
br i1 %115, label %134, label %116
116: ; preds = %113
%117 = getelementptr inbounds float, float* %4, i64 %114
%118 = bitcast float* %117 to <4 x float>*
%119 = load <4 x float>, <4 x float>* %118
%120 = getelementptr inbounds float, float* %0, i64 %114
%121 = bitcast float* %120 to <4 x float>*
%122 = load <4 x float>, <4 x float>* %121
%123 = fsub <4 x float> %119, %122
%124 = getelementptr inbounds float, float* %1, i64 %114
%125 = bitcast float* %124 to <4 x float>*
store <4 x float> %123, <4 x float>* %125
%126 = getelementptr inbounds float, float* %2, i64 %114
%127 = bitcast float* %126 to <4 x float>*
%128 = load <4 x float>, <4 x float>* %127
%129 = getelementptr inbounds float, float* %3, i64 %114
%130 = bitcast float* %129 to <4 x float>*
%131 = load <4 x float>, <4 x float>* %130
%132 = fadd <4 x float> %128, %131
%133 = bitcast float* %120 to <4 x float>*
store <4 x float> %132, <4 x float>* %133
br label %134
134: ; preds = %113, %116
%135 = icmp eq i64 %19, %60
br i1 %135, label %185, label %136
136: ; preds = %21, %18, %134
%137 = phi i64 [ 1, %21 ], [ 1, %18 ], [ %61, %134 ]
%138 = xor i64 %137, -1
%139 = and i64 %5, 1
%140 = icmp eq i64 %139, 0
br i1 %140, label %141, label %154
141: ; preds = %136
%142 = getelementptr inbounds float, float* %4, i64 %137
%143 = load float, float* %142
%144 = getelementptr inbounds float, float* %0, i64 %137
%145 = load float, float* %144
%146 = fsub float %143, %145
%147 = getelementptr inbounds float, float* %1, i64 %137
store float %146, float* %147
%148 = getelementptr inbounds float, float* %2, i64 %137
%149 = load float, float* %148
%150 = getelementptr inbounds float, float* %3, i64 %137
%151 = load float, float* %150
%152 = fadd float %149, %151
store float %152, float* %144
%153 = add nuw nsw i64 %137, 1
br label %154
154: ; preds = %141, %136
%155 = phi i64 [ %137, %136 ], [ %153, %141 ]
%156 = sub i64 0, %5
%157 = icmp eq i64 %138, %156
br i1 %157, label %185, label %158
158: ; preds = %154, %158
%159 = phi i64 [ %183, %158 ], [ %155, %154 ]
%160 = getelementptr inbounds float, float* %4, i64 %159
%161 = load float, float* %160
%162 = getelementptr inbounds float, float* %0, i64 %159
%163 = load float, float* %162
%164 = fsub float %161, %163
%165 = getelementptr inbounds float, float* %1, i64 %159
store float %164, float* %165
%166 = getelementptr inbounds float, float* %2, i64 %159
%167 = load float, float* %166
%168 = getelementptr inbounds float, float* %3, i64 %159
%169 = load float, float* %168
%170 = fadd float %167, %169
store float %170, float* %162
%171 = add nuw nsw i64 %159, 1
%172 = getelementptr inbounds float, float* %4, i64 %171
%173 = load float, float* %172
%174 = getelementptr inbounds float, float* %0, i64 %171
%175 = load float, float* %174
%176 = fsub float %173, %175
%177 = getelementptr inbounds float, float* %1, i64 %171
store float %176, float* %177
%178 = getelementptr inbounds float, float* %2, i64 %171
%179 = load float, float* %178
%180 = getelementptr inbounds float, float* %3, i64 %171
%181 = load float, float* %180
%182 = fadd float %179, %181
store float %182, float* %174
%183 = add nuw nsw i64 %159, 2
%184 = icmp eq i64 %183, %5
br i1 %184, label %185, label %158
185: ; preds = %154, %158, %134, %6
ret void
}