void horn_derives(image1, image2, dx, dy, dt, nx, ny) float *image1, *image2,
    *dy, *dx, *dt;
int nx, ny;
{
  int index, i, j;
  for (i = 0; i < ny - 1; i++) {
    for (j = 0; j < nx - 1; j++) {
      index = (i * nx) + j;
      dy[index] = ((image1[index + nx] + image2[index + nx] +
                    image1[index + nx + 1] + image2[index + nx + 1]) -
                   (image1[index] + image2[index] + image1[index + 1] +
                    image2[index + 1])) /
                  4.0;
      dx[index] = ((image1[index + 1] + image2[index + 1] +
                    image1[index + nx + 1] + image2[index + nx + 1]) -
                   (image1[index] + image2[index] + image1[index + nx] +
                    image2[index + nx])) /
                  4.0;
      dt[index] = ((image2[index] + image2[index + 1] + image2[index + nx] +
                    image2[index + nx + 1]) -
                   (image1[index] + image1[index + 1] + image1[index + nx] +
                    image1[index + nx + 1])) /
                  4.0;
    }
  }
  for (j = 0; j < nx; j++) {
    index = (ny - 1) * nx + j;
    dx[index] = 0.0;
    dy[index] = 0.0;
    dt[index] = 0.0;
  }
  for (i = 0; i < ny; i++) {
    index = (i * nx) + (nx - 1);
    dx[index] = 0.0;
    dy[index] = 0.0;
    dt[index] = 0.0;
  }
}


x86 assembly (clang, -O0):
<horn_derives>:
push   %rbp
mov    %rsp,%rbp
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    0x10(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1390 <horn_derives+0x290>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    137d <horn_derives+0x27d>
mov    -0x34(%rbp),%eax
imul   -0x2c(%rbp),%eax
add    -0x38(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm1
subss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xe08(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm1
subss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xd57(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm1
subss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xca6(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    113e <horn_derives+0x3e>
jmp    1382 <horn_derives+0x282>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1126 <horn_derives+0x26>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    13f1 <horn_derives+0x2f1>
mov    0x10(%rbp),%eax
sub    $0x1,%eax
imul   -0x2c(%rbp),%eax
add    -0x38(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1397 <horn_derives+0x297>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1454 <horn_derives+0x354>
mov    -0x34(%rbp),%eax
imul   -0x2c(%rbp),%eax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
add    %ecx,%eax
mov    %eax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    13f8 <horn_derives+0x2f8>
pop    %rbp
ret

x86 assembly (clang, -O2):
<horn_derives>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %r8,-0x8(%rsp)
mov    %rcx,%r11
mov    %rdx,-0x18(%rsp)
mov    0x38(%rsp),%ecx
lea    -0x1(%rcx),%r14d
movslq %r9d,%rax
mov    %rax,-0x10(%rsp)
cmp    $0x2,%ecx
jl     128b <horn_derives+0x18b>
mov    -0x10(%rsp),%rcx
lea    -0x1(%rcx),%ebx
mov    %r14d,%r15d
lea    0x0(,%rcx,4),%r12
lea    (%rdi,%rcx,4),%rax
add    $0x4,%rax
add    $0x4,%rdi
lea    (%rsi,%rcx,4),%rbp
add    $0x4,%rbp
add    $0x4,%rsi
shl    $0x2,%rbx
xor    %r13d,%r13d
movss  0xe96(%rip),%xmm0
mov    -0x8(%rsp),%r8
mov    -0x18(%rsp),%rdx
mov    %r11,%rcx
jmp    11a2 <horn_derives+0xa2>
nopl   0x0(%rax)
add    $0x1,%r13
add    %r12,%rdi
add    %r12,%rsi
add    %r12,%rcx
add    %r12,%rdx
add    %r12,%r8
add    %r12,%rax
add    %r12,%rbp
cmp    %r15,%r13
je     128b <horn_derives+0x18b>
cmp    $0x2,%r9d
jl     1180 <horn_derives+0x80>
xor    %r10d,%r10d
nopl   0x0(%rax,%rax,1)
movss  -0x4(%rax,%r10,1),%xmm1
addss  -0x4(%rbp,%r10,1),%xmm1
addss  (%rax,%r10,1),%xmm1
addss  0x0(%rbp,%r10,1),%xmm1
movss  -0x4(%rdi,%r10,1),%xmm2
addss  -0x4(%rsi,%r10,1),%xmm2
addss  (%rdi,%r10,1),%xmm2
addss  (%rsi,%r10,1),%xmm2
subss  %xmm2,%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%rcx,%r10,1)
movss  -0x4(%rdi,%r10,1),%xmm1
movss  (%rdi,%r10,1),%xmm2
addss  (%rsi,%r10,1),%xmm2
addss  (%rax,%r10,1),%xmm2
addss  0x0(%rbp,%r10,1),%xmm2
addss  -0x4(%rsi,%r10,1),%xmm1
addss  -0x4(%rax,%r10,1),%xmm1
addss  -0x4(%rbp,%r10,1),%xmm1
subss  %xmm1,%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,(%rdx,%r10,1)
movss  -0x4(%rsi,%r10,1),%xmm1
addss  (%rsi,%r10,1),%xmm1
addss  -0x4(%rbp,%r10,1),%xmm1
addss  0x0(%rbp,%r10,1),%xmm1
movss  -0x4(%rdi,%r10,1),%xmm2
addss  (%rdi,%r10,1),%xmm2
addss  -0x4(%rax,%r10,1),%xmm2
addss  (%rax,%r10,1),%xmm2
subss  %xmm2,%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%r8,%r10,1)
add    $0x4,%r10
cmp    %r10,%rbx
jne    11b0 <horn_derives+0xb0>
jmp    1180 <horn_derives+0x80>
test   %r9d,%r9d
mov    -0x8(%rsp),%r13
jle    148e <horn_derives+0x38e>
imul   %r9d,%r14d
movslq %r14d,%r10
mov    %r9d,%esi
cmp    $0x8,%r9d
jae    134b <horn_derives+0x24b>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
test   $0x1,%sil
je     12e0 <horn_derives+0x1e0>
lea    (%rax,%r10,1),%rdx
mov    -0x18(%rsp),%rdi
movl   $0x0,(%rdi,%rdx,4)
movl   $0x0,(%r11,%rdx,4)
movl   $0x0,0x0(%r13,%rdx,4)
or     $0x1,%rax
add    %rsi,%rcx
je     148e <horn_derives+0x38e>
mov    -0x18(%rsp),%rcx
lea    (%rcx,%r10,4),%rcx
add    $0x4,%rcx
lea    (%r11,%r10,4),%rdx
add    $0x4,%rdx
lea    0x4(,%r10,4),%rdi
add    %r13,%rdi
nopl   0x0(%rax)
movl   $0x0,-0x4(%rcx,%rax,4)
movl   $0x0,-0x4(%rdx,%rax,4)
movl   $0x0,-0x4(%rdi,%rax,4)
movl   $0x0,(%rcx,%rax,4)
movl   $0x0,(%rdx,%rax,4)
movl   $0x0,(%rdi,%rax,4)
add    $0x2,%rax
cmp    %rax,%rsi
jne    1310 <horn_derives+0x210>
jmp    148e <horn_derives+0x38e>
mov    -0x18(%rsp),%rdx
lea    (%rdx,%r10,4),%rax
lea    (%r10,%rsi,1),%rcx
lea    (%rdx,%rcx,4),%rdx
lea    (%r11,%r10,4),%rdi
lea    (%r11,%rcx,4),%rbp
lea    0x0(,%r10,4),%rbx
add    %r13,%rbx
lea    0x0(,%rcx,4),%rcx
add    %r13,%rcx
cmp    %rbp,%rax
setb   %r15b
cmp    %rdx,%rdi
setb   %r12b
cmp    %rcx,%rax
setb   %r14b
cmp    %rdx,%rbx
setb   %r8b
cmp    %rcx,%rdi
setb   %dl
cmp    %rbp,%rbx
setb   %dil
xor    %eax,%eax
test   %r12b,%r15b
jne    12af <horn_derives+0x1af>
and    %r8b,%r14b
jne    12af <horn_derives+0x1af>
and    %dil,%dl
jne    12af <horn_derives+0x1af>
mov    %esi,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rcx
mov    %rcx,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rcx,%rcx
je     156e <horn_derives+0x46e>
mov    %r8,%rcx
and    $0xfffffffffffffffe,%rcx
lea    0x30(,%r10,4),%rbx
add    %r13,%rbx
lea    (%r11,%r10,4),%rbp
add    $0x30,%rbp
mov    -0x18(%rsp),%rdx
lea    (%rdx,%r10,4),%rdi
add    $0x30,%rdi
xor    %edx,%edx
xorps  %xmm0,%xmm0
nopl   0x0(%rax)
movups %xmm0,-0x30(%rdi,%rdx,4)
movups %xmm0,-0x20(%rdi,%rdx,4)
movups %xmm0,-0x30(%rbp,%rdx,4)
movups %xmm0,-0x20(%rbp,%rdx,4)
movups %xmm0,-0x30(%rbx,%rdx,4)
movups %xmm0,-0x20(%rbx,%rdx,4)
movups %xmm0,-0x10(%rdi,%rdx,4)
movups %xmm0,(%rdi,%rdx,4)
movups %xmm0,-0x10(%rbp,%rdx,4)
movups %xmm0,0x0(%rbp,%rdx,4)
movups %xmm0,-0x10(%rbx,%rdx,4)
movups %xmm0,(%rbx,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rcx
jne    1410 <horn_derives+0x310>
test   $0x1,%r8b
je     1485 <horn_derives+0x385>
add    %r10,%rdx
xorps  %xmm0,%xmm0
mov    -0x18(%rsp),%rcx
movups %xmm0,(%rcx,%rdx,4)
movups %xmm0,0x10(%rcx,%rdx,4)
movups %xmm0,(%r11,%rdx,4)
movups %xmm0,0x10(%r11,%rdx,4)
movups %xmm0,0x0(%r13,%rdx,4)
movups %xmm0,0x10(%r13,%rdx,4)
cmp    %rsi,%rax
jne    12af <horn_derives+0x1af>
mov    0x38(%rsp),%eax
test   %eax,%eax
jle    1563 <horn_derives+0x463>
add    $0xffffffff,%r9d
movslq %r9d,%r9
mov    %eax,%r8d
cmp    $0x1,%eax
jne    14b0 <horn_derives+0x3b0>
xor    %edx,%edx
jmp    1537 <horn_derives+0x437>
mov    %r8d,%r10d
and    $0xfffffffe,%r10d
mov    -0x10(%rsp),%rcx
lea    (%rcx,%r9,1),%rax
lea    0x0(,%rax,4),%r14
add    %r13,%r14
lea    0x0(,%rcx,8),%r15
lea    (%r11,%rax,4),%rbx
mov    -0x18(%rsp),%rdx
lea    (%rdx,%rax,4),%rcx
lea    (%rdx,%r9,4),%rax
lea    (%r11,%r9,4),%rsi
lea    0x0(,%r9,4),%rdi
add    %r13,%rdi
xor    %ebp,%ebp
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movl   $0x0,(%rax,%rbp,1)
movl   $0x0,(%rsi,%rbp,1)
movl   $0x0,(%rdi,%rbp,1)
movl   $0x0,(%rcx,%rbp,1)
movl   $0x0,(%rbx,%rbp,1)
movl   $0x0,(%r14,%rbp,1)
add    $0x2,%rdx
add    %r15,%rbp
cmp    %rdx,%r10
jne    1500 <horn_derives+0x400>
test   $0x1,%r8b
je     1563 <horn_derives+0x463>
imul   -0x10(%rsp),%rdx
add    %r9,%rdx
mov    -0x18(%rsp),%rax
movl   $0x0,(%rax,%rdx,4)
movl   $0x0,(%r11,%rdx,4)
movl   $0x0,0x0(%r13,%rdx,4)
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %edx,%edx
test   $0x1,%r8b
jne    145a <horn_derives+0x35a>
jmp    1485 <horn_derives+0x385>

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

LLVM IR (-O2):
define void @horn_derives(float* nocapture %0, float* nocapture %1, float* nocapture writeonly %2, float* nocapture writeonly %3, float* nocapture writeonly %4, i32 %5, i32 %6) {
%8 = add i32 %6, -1
%9 = icmp sgt i32 %6, 1
br i1 %9, label %10, label %20
10: ; preds = %7
%11 = add i32 %5, -1
%12 = icmp sgt i32 %5, 1
%13 = sext i32 %5 to i64
%14 = zext i32 %8 to i64
%15 = zext i32 %11 to i64
br label %16
16: ; preds = %10, %189
%17 = phi i64 [ 0, %10 ], [ %190, %189 ]
br i1 %12, label %18, label %189
18: ; preds = %16
%19 = mul nsw i64 %17, %13
br label %122
20: ; preds = %189, %7
%21 = icmp sgt i32 %5, 0
br i1 %21, label %22, label %192
22: ; preds = %20
%23 = mul nsw i32 %8, %5
%24 = sext i32 %23 to i64
%25 = zext i32 %5 to i64
%26 = icmp ult i32 %5, 8
br i1 %26, label %107, label %27
27: ; preds = %22
%28 = getelementptr float, float* %2, i64 %24
%29 = add nsw i64 %24, %25
%30 = getelementptr float, float* %2, i64 %29
%31 = getelementptr float, float* %3, i64 %24
%32 = getelementptr float, float* %3, i64 %29
%33 = getelementptr float, float* %4, i64 %24
%34 = getelementptr float, float* %4, i64 %29
%35 = icmp ult float* %28, %32
%36 = icmp ult float* %31, %30
%37 = and i1 %35, %36
%38 = icmp ult float* %28, %34
%39 = icmp ult float* %33, %30
%40 = and i1 %38, %39
%41 = or i1 %37, %40
%42 = icmp ult float* %31, %34
%43 = icmp ult float* %33, %32
%44 = and i1 %42, %43
%45 = or i1 %41, %44
br i1 %45, label %107, label %46
46: ; preds = %27
%47 = and i64 %25, 4294967288
%48 = add nsw i64 %47, -8
%49 = lshr exact i64 %48, 3
%50 = add nuw nsw i64 %49, 1
%51 = and i64 %50, 1
%52 = icmp eq i64 %48, 0
br i1 %52, label %88, label %53
53: ; preds = %46
%54 = and i64 %50, 4611686018427387902
br label %55
55: ; preds = %55, %53
%56 = phi i64 [ 0, %53 ], [ %85, %55 ]
%57 = phi i64 [ 0, %53 ], [ %86, %55 ]
%58 = add nsw i64 %56, %24
%59 = getelementptr inbounds float, float* %2, i64 %58
%60 = bitcast float* %59 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %60
%61 = getelementptr inbounds float, float* %59, i64 4
%62 = bitcast float* %61 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %62
%63 = getelementptr inbounds float, float* %3, i64 %58
%64 = bitcast float* %63 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %64
%65 = getelementptr inbounds float, float* %63, i64 4
%66 = bitcast float* %65 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %66
%67 = getelementptr inbounds float, float* %4, i64 %58
%68 = bitcast float* %67 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %68
%69 = getelementptr inbounds float, float* %67, i64 4
%70 = bitcast float* %69 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %70
%71 = or i64 %56, 8
%72 = add nsw i64 %71, %24
%73 = getelementptr inbounds float, float* %2, i64 %72
%74 = bitcast float* %73 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %74
%75 = getelementptr inbounds float, float* %73, i64 4
%76 = bitcast float* %75 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %76
%77 = getelementptr inbounds float, float* %3, i64 %72
%78 = bitcast float* %77 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %78
%79 = getelementptr inbounds float, float* %77, i64 4
%80 = bitcast float* %79 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %80
%81 = getelementptr inbounds float, float* %4, i64 %72
%82 = bitcast float* %81 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %82
%83 = getelementptr inbounds float, float* %81, i64 4
%84 = bitcast float* %83 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %84
%85 = add nuw i64 %56, 16
%86 = add i64 %57, 2
%87 = icmp eq i64 %86, %54
br i1 %87, label %88, label %55
88: ; preds = %55, %46
%89 = phi i64 [ 0, %46 ], [ %85, %55 ]
%90 = icmp eq i64 %51, 0
br i1 %90, label %105, label %91
91: ; preds = %88
%92 = add nsw i64 %89, %24
%93 = getelementptr inbounds float, float* %2, i64 %92
%94 = bitcast float* %93 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %94
%95 = getelementptr inbounds float, float* %93, i64 4
%96 = bitcast float* %95 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %96
%97 = getelementptr inbounds float, float* %3, i64 %92
%98 = bitcast float* %97 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %98
%99 = getelementptr inbounds float, float* %97, i64 4
%100 = bitcast float* %99 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %100
%101 = getelementptr inbounds float, float* %4, i64 %92
%102 = bitcast float* %101 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %102
%103 = getelementptr inbounds float, float* %101, i64 4
%104 = bitcast float* %103 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %104
br label %105
105: ; preds = %88, %91
%106 = icmp eq i64 %47, %25
br i1 %106, label %192, label %107
107: ; preds = %27, %22, %105
%108 = phi i64 [ 0, %27 ], [ 0, %22 ], [ %47, %105 ]
%109 = xor i64 %108, -1
%110 = and i64 %25, 1
%111 = icmp eq i64 %110, 0
br i1 %111, label %118, label %112
112: ; preds = %107
%113 = add nsw i64 %108, %24
%114 = getelementptr inbounds float, float* %2, i64 %113
store float 0.000000e+00, float* %114
%115 = getelementptr inbounds float, float* %3, i64 %113
store float 0.000000e+00, float* %115
%116 = getelementptr inbounds float, float* %4, i64 %113
store float 0.000000e+00, float* %116
%117 = or i64 %108, 1
br label %118
118: ; preds = %112, %107
%119 = phi i64 [ %108, %107 ], [ %117, %112 ]
%120 = sub nsw i64 0, %25
%121 = icmp eq i64 %109, %120
br i1 %121, label %192, label %203
122: ; preds = %18, %122
%123 = phi i64 [ 0, %18 ], [ %187, %122 ]
%124 = add nsw i64 %123, %19
%125 = add nsw i64 %124, %13
%126 = getelementptr inbounds float, float* %0, i64 %125
%127 = load float, float* %126
%128 = getelementptr inbounds float, float* %1, i64 %125
%129 = load float, float* %128
%130 = fadd float %127, %129
%131 = add nsw i64 %125, 1
%132 = getelementptr inbounds float, float* %0, i64 %131
%133 = load float, float* %132
%134 = fadd float %130, %133
%135 = getelementptr inbounds float, float* %1, i64 %131
%136 = load float, float* %135
%137 = fadd float %134, %136
%138 = getelementptr inbounds float, float* %0, i64 %124
%139 = load float, float* %138
%140 = getelementptr inbounds float, float* %1, i64 %124
%141 = load float, float* %140
%142 = fadd float %139, %141
%143 = add nsw i64 %124, 1
%144 = getelementptr inbounds float, float* %0, i64 %143
%145 = load float, float* %144
%146 = fadd float %142, %145
%147 = getelementptr inbounds float, float* %1, i64 %143
%148 = load float, float* %147
%149 = fadd float %146, %148
%150 = fsub float %137, %149
%151 = fmul float %150, 2.500000e-01
%152 = getelementptr inbounds float, float* %3, i64 %124
store float %151, float* %152
%153 = load float, float* %144
%154 = load float, float* %147
%155 = fadd float %153, %154
%156 = load float, float* %132
%157 = fadd float %155, %156
%158 = load float, float* %135
%159 = fadd float %157, %158
%160 = load float, float* %138
%161 = load float, float* %140
%162 = fadd float %160, %161
%163 = load float, float* %126
%164 = fadd float %162, %163
%165 = load float, float* %128
%166 = fadd float %164, %165
%167 = fsub float %159, %166
%168 = fmul float %167, 2.500000e-01
%169 = getelementptr inbounds float, float* %2, i64 %124
store float %168, float* %169
%170 = load float, float* %140
%171 = load float, float* %147
%172 = fadd float %170, %171
%173 = load float, float* %128
%174 = fadd float %172, %173
%175 = load float, float* %135
%176 = fadd float %174, %175
%177 = load float, float* %138
%178 = load float, float* %144
%179 = fadd float %177, %178
%180 = load float, float* %126
%181 = fadd float %179, %180
%182 = load float, float* %132
%183 = fadd float %181, %182
%184 = fsub float %176, %183
%185 = fmul float %184, 2.500000e-01
%186 = getelementptr inbounds float, float* %4, i64 %124
store float %185, float* %186
%187 = add nuw nsw i64 %123, 1
%188 = icmp eq i64 %187, %15
br i1 %188, label %189, label %122
189: ; preds = %122, %16
%190 = add nuw nsw i64 %17, 1
%191 = icmp eq i64 %190, %14
br i1 %191, label %20, label %16
192: ; preds = %118, %203, %105, %20
%193 = icmp sgt i32 %6, 0
br i1 %193, label %194, label %242
194: ; preds = %192
%195 = add nsw i32 %5, -1
%196 = sext i32 %5 to i64
%197 = sext i32 %195 to i64
%198 = zext i32 %6 to i64
%199 = and i64 %198, 1
%200 = icmp eq i32 %6, 1
br i1 %200, label %233, label %201
201: ; preds = %194
%202 = and i64 %198, 4294967294
br label %216
203: ; preds = %118, %203
%204 = phi i64 [ %214, %203 ], [ %119, %118 ]
%205 = add nsw i64 %204, %24
%206 = getelementptr inbounds float, float* %2, i64 %205
store float 0.000000e+00, float* %206
%207 = getelementptr inbounds float, float* %3, i64 %205
store float 0.000000e+00, float* %207
%208 = getelementptr inbounds float, float* %4, i64 %205
store float 0.000000e+00, float* %208
%209 = add nuw nsw i64 %204, 1
%210 = add nsw i64 %209, %24
%211 = getelementptr inbounds float, float* %2, i64 %210
store float 0.000000e+00, float* %211
%212 = getelementptr inbounds float, float* %3, i64 %210
store float 0.000000e+00, float* %212
%213 = getelementptr inbounds float, float* %4, i64 %210
store float 0.000000e+00, float* %213
%214 = add nuw nsw i64 %204, 2
%215 = icmp eq i64 %214, %25
br i1 %215, label %192, label %203
216: ; preds = %216, %201
%217 = phi i64 [ 0, %201 ], [ %230, %216 ]
%218 = phi i64 [ 0, %201 ], [ %231, %216 ]
%219 = mul nsw i64 %217, %196
%220 = add nsw i64 %219, %197
%221 = getelementptr inbounds float, float* %2, i64 %220
store float 0.000000e+00, float* %221
%222 = getelementptr inbounds float, float* %3, i64 %220
store float 0.000000e+00, float* %222
%223 = getelementptr inbounds float, float* %4, i64 %220
store float 0.000000e+00, float* %223
%224 = or i64 %217, 1
%225 = mul nsw i64 %224, %196
%226 = add nsw i64 %225, %197
%227 = getelementptr inbounds float, float* %2, i64 %226
store float 0.000000e+00, float* %227
%228 = getelementptr inbounds float, float* %3, i64 %226
store float 0.000000e+00, float* %228
%229 = getelementptr inbounds float, float* %4, i64 %226
store float 0.000000e+00, float* %229
%230 = add nuw nsw i64 %217, 2
%231 = add i64 %218, 2
%232 = icmp eq i64 %231, %202
br i1 %232, label %233, label %216
233: ; preds = %216, %194
%234 = phi i64 [ 0, %194 ], [ %230, %216 ]
%235 = icmp eq i64 %199, 0
br i1 %235, label %242, label %236
236: ; preds = %233
%237 = mul nsw i64 %234, %196
%238 = add nsw i64 %237, %197
%239 = getelementptr inbounds float, float* %2, i64 %238
store float 0.000000e+00, float* %239
%240 = getelementptr inbounds float, float* %3, i64 %238
store float 0.000000e+00, float* %240
%241 = getelementptr inbounds float, float* %4, i64 %238
store float 0.000000e+00, float* %241
br label %242
242: ; preds = %236, %233, %192
ret void
}