#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 */
scalar_t__ abs(float);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *);
int /*<<< orphan*/ stderr;
float getWindowMatch(float *tplateRows, float *srchRows, int nrows,
                     int rowstride, int w, int range) {
  int r, i, j;
  float diff;
  float vals[64] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
  float max;
  float a, b, dx;
  float *tptr = NULL;
  float *sptr = NULL;
  for (r = 0; r <= range; r++) {
    tptr = tplateRows;
    sptr = srchRows + r;
    for (j = 0; j < nrows; j++) {
      for (i = 0; i < w; i++) {
        diff = (*sptr) - (*tptr);
        vals[r] -= abs(diff);
        sptr++;
        tptr++;
      }
      tptr = tptr + rowstride - w;
      sptr = sptr + rowstride - w;
    }
  }
  i = 0;
  max = vals[0];
  for (r = 1; r <= range; r++) {
    if (max < vals[r]) {
      max = vals[r];
      i = r;
    }
  }
  if (i == 0 || i == range) {
    return i;
  }
  a = (vals[i + 1] + vals[i - 1] - 2 * vals[i]);
  if (a == 0) {
    return i;
  }
  b = (vals[i + 1] - vals[i - 1]);
  dx = -0.5 * b / a;
  if (dx > 1 || dx < -1) {
    fprintf(stderr, "dx>1\n");
    return i;
  }
  return i + dx;
}


x86 assembly (clang, -O0):
<getWindowMatch>:
push   %rbp
mov    %rsp,%rbp
sub    $0x160,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
mov    %ecx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    %r9d,-0x28(%rbp)
lea    -0x140(%rbp),%rdi
xor    %esi,%esi
mov    $0x100,%edx
call   1040 <memset@plt>
movq   $0x0,-0x158(%rbp)
movq   $0x0,-0x160(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jg     12bd <getWindowMatch+0x18d>
mov    -0x10(%rbp),%rax
mov    %rax,-0x158(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x160(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    12aa <getWindowMatch+0x17a>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    124a <getWindowMatch+0x11a>
mov    -0x160(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x158(%rbp),%rax
subss  (%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x38(%rbp),%xmm0
call   1030 <abs@plt>
cvtsi2ss %rax,%xmm1
movslq -0x2c(%rbp),%rax
movss  -0x140(%rbp,%rax,4),%xmm0
ff ff
subss  %xmm1,%xmm0
movss  %xmm0,-0x140(%rbp,%rax,4)
ff ff
mov    -0x160(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x160(%rbp)
mov    -0x158(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x158(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11c8 <getWindowMatch+0x98>
mov    -0x158(%rbp),%rax
movslq -0x20(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x158(%rbp)
mov    -0x160(%rbp),%rax
movslq -0x20(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x160(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11b5 <getWindowMatch+0x85>
jmp    12af <getWindowMatch+0x17f>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1181 <getWindowMatch+0x51>
movl   $0x0,-0x30(%rbp)
movss  -0x140(%rbp),%xmm0
ff
movss  %xmm0,-0x144(%rbp)
ff
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jg     1333 <getWindowMatch+0x203>
movss  -0x144(%rbp),%xmm1
ff
movslq -0x2c(%rbp),%rax
movss  -0x140(%rbp,%rax,4),%xmm0
ff ff
ucomiss %xmm1,%xmm0
jbe    1320 <getWindowMatch+0x1f0>
movslq -0x2c(%rbp),%rax
movss  -0x140(%rbp,%rax,4),%xmm0
ff ff
movss  %xmm0,-0x144(%rbp)
ff
mov    -0x2c(%rbp),%eax
mov    %eax,-0x30(%rbp)
jmp    1325 <getWindowMatch+0x1f5>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    12db <getWindowMatch+0x1ab>
cmpl   $0x0,-0x30(%rbp)
je     1349 <getWindowMatch+0x219>
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jne    1358 <getWindowMatch+0x228>
cvtsi2ssl -0x30(%rbp),%xmm0
movss  %xmm0,-0x4(%rbp)
jmp    1482 <getWindowMatch+0x352>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
cltq
movss  -0x140(%rbp,%rax,4),%xmm0
ff ff
mov    -0x30(%rbp),%eax
sub    $0x1,%eax
cltq
addss  -0x140(%rbp,%rax,4),%xmm0
ff ff
movslq -0x30(%rbp),%rax
movss  -0x140(%rbp,%rax,4),%xmm1
ff ff
addss  %xmm1,%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,-0x148(%rbp)
ff
movss  -0x148(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    13c0 <getWindowMatch+0x290>
jp     13c0 <getWindowMatch+0x290>
cvtsi2ssl -0x30(%rbp),%xmm0
movss  %xmm0,-0x4(%rbp)
jmp    1482 <getWindowMatch+0x352>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
cltq
movss  -0x140(%rbp,%rax,4),%xmm0
ff ff
mov    -0x30(%rbp),%eax
sub    $0x1,%eax
cltq
subss  -0x140(%rbp,%rax,4),%xmm0
ff ff
movss  %xmm0,-0x14c(%rbp)
ff
movss  -0x14c(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movsd  0xc0a(%rip),%xmm0
mulsd  %xmm1,%xmm0
movss  -0x148(%rbp),%xmm1
ff
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x150(%rbp)
ff
movss  -0x150(%rbp),%xmm0
ff
movss  0xbd2(%rip),%xmm1
ucomiss %xmm1,%xmm0
ja     144c <getWindowMatch+0x31c>
movss  0xbc5(%rip),%xmm0
ucomiss -0x150(%rbp),%xmm0
jbe    1470 <getWindowMatch+0x340>
mov    0x2b8d(%rip),%rax
mov    (%rax),%edi
lea    0xbb4(%rip),%rsi
call   1050 <fprintf@plt>
cvtsi2ssl -0x30(%rbp),%xmm0
movss  %xmm0,-0x4(%rbp)
jmp    1482 <getWindowMatch+0x352>
cvtsi2ssl -0x30(%rbp),%xmm0
addss  -0x150(%rbp),%xmm0
ff
movss  %xmm0,-0x4(%rbp)
movss  -0x4(%rbp),%xmm0
add    $0x160,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<getWindowMatch>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x148,%rsp
mov    %rsi,0x28(%rsp)
mov    %rdi,0x20(%rsp)
xorps  %xmm0,%xmm0
movaps %xmm0,0x130(%rsp)
movaps %xmm0,0x120(%rsp)
movaps %xmm0,0x110(%rsp)
movaps %xmm0,0x100(%rsp)
movaps %xmm0,0xf0(%rsp)
movaps %xmm0,0xe0(%rsp)
movaps %xmm0,0xd0(%rsp)
movaps %xmm0,0xc0(%rsp)
movaps %xmm0,0xb0(%rsp)
movaps %xmm0,0xa0(%rsp)
movaps %xmm0,0x90(%rsp)
movaps %xmm0,0x80(%rsp)
movaps %xmm0,0x70(%rsp)
movaps %xmm0,0x60(%rsp)
movaps %xmm0,0x50(%rsp)
movaps %xmm0,0x40(%rsp)
test   %r9d,%r9d
js     1371 <getWindowMatch+0x251>
mov    %edx,%ebx
movslq %ecx,%rax
mov    %rax,0x38(%rsp)
movslq %r8d,%r15
mov    %r15,%rax
neg    %rax
mov    %rax,0x30(%rsp)
mov    %r9,0x18(%rsp)
lea    0x1(%r9),%eax
mov    %rax,0x10(%rsp)
and    $0xfffffffe,%r15d
xor    %r13d,%r13d
mov    %r8d,0x4(%rsp)
mov    %edx,0x8(%rsp)
jmp    120f <getWindowMatch+0xef>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r13
cmp    0x10(%rsp),%r13
je     133d <getWindowMatch+0x21d>
test   %ebx,%ebx
jle    1200 <getWindowMatch+0xe0>
mov    0x28(%rsp),%rax
lea    (%rax,%r13,4),%rbp
xor    %r12d,%r12d
mov    0x20(%rsp),%r14
jmp    125a <getWindowMatch+0x13a>
cs nopw 0x0(%rax,%rax,1)
mov    0x38(%rsp),%rcx
lea    (%r14,%rcx,4),%rax
mov    0x30(%rsp),%rdi
lea    (%rax,%rdi,4),%r14
lea    0x0(,%rcx,4),%rax
add    %rbp,%rax
lea    (%rax,%rdi,4),%rbp
add    $0x1,%r12d
cmp    %ebx,%r12d
je     1200 <getWindowMatch+0xe0>
test   %r8d,%r8d
jle    1230 <getWindowMatch+0x110>
cmp    $0x1,%r8d
je     12f8 <getWindowMatch+0x1d8>
mov    %r12d,0xc(%rsp)
xor    %ebx,%ebx
xor    %r12d,%r12d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  0x0(%rbp,%rbx,4),%xmm0
subss  (%r14,%rbx,4),%xmm0
call   1030 <abs@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
movss  0x40(%rsp,%r13,4),%xmm1
subss  %xmm0,%xmm1
movss  %xmm1,0x40(%rsp,%r13,4)
movss  0x4(%rbp,%rbx,4),%xmm0
subss  0x4(%r14,%rbx,4),%xmm0
call   1030 <abs@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
movss  0x40(%rsp,%r13,4),%xmm1
subss  %xmm0,%xmm1
movss  %xmm1,0x40(%rsp,%r13,4)
add    $0xfffffffffffffff8,%r12
add    $0x2,%rbx
cmp    %ebx,%r15d
jne    1280 <getWindowMatch+0x160>
sub    %r12,%rbp
sub    %r12,%r14
mov    0x4(%rsp),%r8d
mov    0x8(%rsp),%ebx
mov    0xc(%rsp),%r12d
test   $0x1,%r8b
je     1230 <getWindowMatch+0x110>
movss  0x0(%rbp),%xmm0
subss  (%r14),%xmm0
call   1030 <abs@plt>
mov    0x4(%rsp),%r8d
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
movss  0x40(%rsp,%r13,4),%xmm1
subss  %xmm0,%xmm1
movss  %xmm1,0x40(%rsp,%r13,4)
add    $0x4,%rbp
add    $0x4,%r14
jmp    1230 <getWindowMatch+0x110>
mov    0x18(%rsp),%r8
test   %r8d,%r8d
jle    1371 <getWindowMatch+0x251>
movss  0x40(%rsp),%xmm0
mov    0x10(%rsp),%rcx
lea    -0x1(%rcx),%rdx
add    $0xfffffffffffffffe,%rcx
mov    %edx,%eax
and    $0x3,%eax
cmp    $0x3,%rcx
jae    138c <getWindowMatch+0x26c>
xor    %ebx,%ebx
mov    $0x1,%ecx
jmp    13f6 <getWindowMatch+0x2d6>
xor    %ebx,%ebx
xorps  %xmm0,%xmm0
cvtsi2ss %ebx,%xmm0
add    $0x148,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
and    $0xfffffffffffffffc,%rdx
xor    %ebx,%ebx
mov    $0x1,%ecx
xor    %esi,%esi
nopl   0x0(%rax)
movss  0x40(%rsp,%rcx,4),%xmm1
ucomiss %xmm0,%xmm1
cmova  %ecx,%ebx
movss  0x44(%rsp,%rcx,4),%xmm2
maxss  %xmm0,%xmm1
ucomiss %xmm1,%xmm2
lea    0x1(%rcx),%edi
cmovbe %ebx,%edi
maxss  %xmm1,%xmm2
movss  0x48(%rsp,%rcx,4),%xmm1
ucomiss %xmm2,%xmm1
lea    0x2(%rcx),%ebp
cmovbe %edi,%ebp
maxss  %xmm2,%xmm1
movss  0x4c(%rsp,%rcx,4),%xmm0
ucomiss %xmm1,%xmm0
lea    0x3(%rcx),%ebx
cmovbe %ebp,%ebx
maxss  %xmm1,%xmm0
add    $0x4,%rcx
add    $0x4,%rsi
cmp    %rdx,%rsi
jne    13a0 <getWindowMatch+0x280>
test   %rax,%rax
je     141d <getWindowMatch+0x2fd>
nopl   0x0(%rax,%rax,1)
movss  0x40(%rsp,%rcx,4),%xmm1
ucomiss %xmm0,%xmm1
cmova  %ecx,%ebx
maxss  %xmm0,%xmm1
add    $0x1,%rcx
movaps %xmm1,%xmm0
add    $0xffffffffffffffff,%rax
jne    1400 <getWindowMatch+0x2e0>
test   %ebx,%ebx
je     1373 <getWindowMatch+0x253>
cmp    %r8d,%ebx
je     1373 <getWindowMatch+0x253>
movslq %ebx,%rax
movss  0x44(%rsp,%rax,4),%xmm1
movss  0x3c(%rsp,%rax,4),%xmm2
movss  0x40(%rsp,%rax,4),%xmm3
movaps %xmm1,%xmm0
addss  %xmm2,%xmm0
addss  %xmm3,%xmm3
subss  %xmm3,%xmm0
xorps  %xmm3,%xmm3
ucomiss %xmm3,%xmm0
jne    1460 <getWindowMatch+0x340>
jnp    1373 <getWindowMatch+0x253>
subss  %xmm2,%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  0xb90(%rip),%xmm1
cvtss2sd %xmm0,%xmm0
divsd  %xmm0,%xmm1
cvtsd2ss %xmm1,%xmm1
ucomiss 0xb85(%rip),%xmm1
ja     14a2 <getWindowMatch+0x382>
movss  0xb7f(%rip),%xmm0
ucomiss %xmm1,%xmm0
ja     14a2 <getWindowMatch+0x382>
xorps  %xmm0,%xmm0
cvtsi2ss %ebx,%xmm0
addss  %xmm1,%xmm0
jmp    137a <getWindowMatch+0x25a>
mov    0x2b37(%rip),%rax
mov    (%rax),%edi
lea    0xb5e(%rip),%rsi
call   1040 <fprintf@plt>
jmp    1373 <getWindowMatch+0x253>

LLVM IR (-O0):
@stderr = global i32 0
@.str = [6 x i8] c"dx>1\0A\00"
define float @getWindowMatch(float* %0, float* %1, i32 %2, i32 %3, i32 %4, i32 %5) {
%7 = alloca float
%8 = alloca float*
%9 = alloca float*
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca float
%18 = alloca [64 x float]
%19 = alloca float
%20 = alloca float
%21 = alloca float
%22 = alloca float
%23 = alloca float*
%24 = alloca float*
store float* %0, float** %8
store float* %1, float** %9
store i32 %2, i32* %10
store i32 %3, i32* %11
store i32 %4, i32* %12
store i32 %5, i32* %13
%25 = bitcast [64 x float]* %18 to i8*
store float* null, float** %23
store float* null, float** %24
store i32 0, i32* %14
br label %26
26: ; preds = %87, %6
%27 = load i32, i32* %14
%28 = load i32, i32* %13
%29 = icmp sle i32 %27, %28
br i1 %29, label %30, label %90
30: ; preds = %26
%31 = load float*, float** %8
store float* %31, float** %23
%32 = load float*, float** %9
%33 = load i32, i32* %14
%34 = sext i32 %33 to i64
%35 = getelementptr inbounds float, float* %32, i64 %34
store float* %35, float** %24
store i32 0, i32* %16
br label %36
36: ; preds = %83, %30
%37 = load i32, i32* %16
%38 = load i32, i32* %10
%39 = icmp slt i32 %37, %38
br i1 %39, label %40, label %86
40: ; preds = %36
store i32 0, i32* %15
br label %41
41: ; preds = %63, %40
%42 = load i32, i32* %15
%43 = load i32, i32* %12
%44 = icmp slt i32 %42, %43
br i1 %44, label %45, label %66
45: ; preds = %41
%46 = load float*, float** %24
%47 = load float, float* %46
%48 = load float*, float** %23
%49 = load float, float* %48
%50 = fsub float %47, %49
store float %50, float* %17
%51 = load float, float* %17
%52 = call i64 @abs(float %51)
%53 = sitofp i64 %52 to float
%54 = load i32, i32* %14
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds [64 x float], [64 x float]* %18, i64 0, i64 %55
%57 = load float, float* %56
%58 = fsub float %57, %53
store float %58, float* %56
%59 = load float*, float** %24
%60 = getelementptr inbounds float, float* %59, i32 1
store float* %60, float** %24
%61 = load float*, float** %23
%62 = getelementptr inbounds float, float* %61, i32 1
store float* %62, float** %23
br label %63
63: ; preds = %45
%64 = load i32, i32* %15
%65 = add nsw i32 %64, 1
store i32 %65, i32* %15
br label %41
66: ; preds = %41
%67 = load float*, float** %23
%68 = load i32, i32* %11
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds float, float* %67, i64 %69
%71 = load i32, i32* %12
%72 = sext i32 %71 to i64
%73 = sub i64 0, %72
%74 = getelementptr inbounds float, float* %70, i64 %73
store float* %74, float** %23
%75 = load float*, float** %24
%76 = load i32, i32* %11
%77 = sext i32 %76 to i64
%78 = getelementptr inbounds float, float* %75, i64 %77
%79 = load i32, i32* %12
%80 = sext i32 %79 to i64
%81 = sub i64 0, %80
%82 = getelementptr inbounds float, float* %78, i64 %81
store float* %82, float** %24
br label %83
83: ; preds = %66
%84 = load i32, i32* %16
%85 = add nsw i32 %84, 1
store i32 %85, i32* %16
br label %36
86: ; preds = %36
br label %87
87: ; preds = %86
%88 = load i32, i32* %14
%89 = add nsw i32 %88, 1
store i32 %89, i32* %14
br label %26
90: ; preds = %26
store i32 0, i32* %15
%91 = getelementptr inbounds [64 x float], [64 x float]* %18, i64 0, i64 0
%92 = load float, float* %91
store float %92, float* %19
store i32 1, i32* %14
br label %93
93: ; preds = %111, %90
%94 = load i32, i32* %14
%95 = load i32, i32* %13
%96 = icmp sle i32 %94, %95
br i1 %96, label %97, label %114
97: ; preds = %93
%98 = load float, float* %19
%99 = load i32, i32* %14
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds [64 x float], [64 x float]* %18, i64 0, i64 %100
%102 = load float, float* %101
%103 = fcmp olt float %98, %102
br i1 %103, label %104, label %110
104: ; preds = %97
%105 = load i32, i32* %14
%106 = sext i32 %105 to i64
%107 = getelementptr inbounds [64 x float], [64 x float]* %18, i64 0, i64 %106
%108 = load float, float* %107
store float %108, float* %19
%109 = load i32, i32* %14
store i32 %109, i32* %15
br label %110
110: ; preds = %104, %97
br label %111
111: ; preds = %110
%112 = load i32, i32* %14
%113 = add nsw i32 %112, 1
store i32 %113, i32* %14
br label %93
114: ; preds = %93
%115 = load i32, i32* %15
%116 = icmp eq i32 %115, 0
br i1 %116, label %121, label %117
117: ; preds = %114
%118 = load i32, i32* %15
%119 = load i32, i32* %13
%120 = icmp eq i32 %118, %119
br i1 %120, label %121, label %124
121: ; preds = %117, %114
%122 = load i32, i32* %15
%123 = sitofp i32 %122 to float
store float %123, float* %7
br label %180
124: ; preds = %117
%125 = load i32, i32* %15
%126 = add nsw i32 %125, 1
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds [64 x float], [64 x float]* %18, i64 0, i64 %127
%129 = load float, float* %128
%130 = load i32, i32* %15
%131 = sub nsw i32 %130, 1
%132 = sext i32 %131 to i64
%133 = getelementptr inbounds [64 x float], [64 x float]* %18, i64 0, i64 %132
%134 = load float, float* %133
%135 = fadd float %129, %134
%136 = load i32, i32* %15
%137 = sext i32 %136 to i64
%138 = getelementptr inbounds [64 x float], [64 x float]* %18, i64 0, i64 %137
%139 = load float, float* %138
%140 = call float @llvm.fmuladd.f32(float -2.000000e+00, float %139, float %135)
store float %140, float* %20
%141 = load float, float* %20
%142 = fcmp oeq float %141, 0.000000e+00
br i1 %142, label %143, label %146
143: ; preds = %124
%144 = load i32, i32* %15
%145 = sitofp i32 %144 to float
store float %145, float* %7
br label %180
146: ; preds = %124
%147 = load i32, i32* %15
%148 = add nsw i32 %147, 1
%149 = sext i32 %148 to i64
%150 = getelementptr inbounds [64 x float], [64 x float]* %18, i64 0, i64 %149
%151 = load float, float* %150
%152 = load i32, i32* %15
%153 = sub nsw i32 %152, 1
%154 = sext i32 %153 to i64
%155 = getelementptr inbounds [64 x float], [64 x float]* %18, i64 0, i64 %154
%156 = load float, float* %155
%157 = fsub float %151, %156
store float %157, float* %21
%158 = load float, float* %21
%159 = fpext float %158 to double
%160 = fmul double -5.000000e-01, %159
%161 = load float, float* %20
%162 = fpext float %161 to double
%163 = fdiv double %160, %162
%164 = fptrunc double %163 to float
store float %164, float* %22
%165 = load float, float* %22
%166 = fcmp ogt float %165, 1.000000e+00
br i1 %166, label %170, label %167
167: ; preds = %146
%168 = load float, float* %22
%169 = fcmp olt float %168, -1.000000e+00
br i1 %169, label %170, label %175
170: ; preds = %167, %146
%171 = load i32, i32* @stderr
%172 = call i32 @fprintf(i32 %171, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0))
%173 = load i32, i32* %15
%174 = sitofp i32 %173 to float
store float %174, float* %7
br label %180
175: ; preds = %167
%176 = load i32, i32* %15
%177 = sitofp i32 %176 to float
%178 = load float, float* %22
%179 = fadd float %177, %178
store float %179, float* %7
br label %180
180: ; preds = %175, %170, %143, %121
%181 = load float, float* %7
ret float %181
}

LLVM IR (-O2):
@stderr = global i32 0
@.str = [6 x i8] c"dx>1\0A\00"
define float @getWindowMatch(float* nocapture %0, float* nocapture %1, i32 %2, i32 %3, i32 %4, i32 %5) {
%7 = alloca [64 x float]
%8 = bitcast [64 x float]* %7 to i8*
%9 = icmp slt i32 %5, 0
br i1 %9, label %154, label %10
10: ; preds = %6
%11 = icmp sgt i32 %2, 0
%12 = icmp sgt i32 %4, 0
%13 = sext i32 %3 to i64
%14 = sext i32 %4 to i64
%15 = sub nsw i64 0, %14
%16 = add nuw i32 %5, 1
%17 = zext i32 %16 to i64
%18 = and i32 %4, 1
%19 = icmp eq i32 %4, 1
%20 = and i32 %4, -2
%21 = icmp eq i32 %18, 0
br label %22
22: ; preds = %10, %80
%23 = phi i64 [ 0, %10 ], [ %81, %80 ]
br i1 %11, label %24, label %80
24: ; preds = %22
%25 = getelementptr inbounds float, float* %1, i64 %23
%26 = getelementptr inbounds [64 x float], [64 x float]* %7, i64 0, i64 %23
br label %27
27: ; preds = %24, %71
%28 = phi float* [ %25, %24 ], [ %77, %71 ]
%29 = phi float* [ %0, %24 ], [ %75, %71 ]
%30 = phi i32 [ 0, %24 ], [ %78, %71 ]
br i1 %12, label %31, label %71
31: ; preds = %27
br i1 %19, label %56, label %32
32: ; preds = %31, %32
%33 = phi float* [ %52, %32 ], [ %28, %31 ]
%34 = phi float* [ %53, %32 ], [ %29, %31 ]
%35 = phi i32 [ %54, %32 ], [ 0, %31 ]
%36 = load float, float* %33
%37 = load float, float* %34
%38 = fsub float %36, %37
%39 = tail call i64 @abs(float %38)
%40 = sitofp i64 %39 to float
%41 = load float, float* %26
%42 = fsub float %41, %40
store float %42, float* %26
%43 = getelementptr inbounds float, float* %33, i64 1
%44 = getelementptr inbounds float, float* %34, i64 1
%45 = load float, float* %43
%46 = load float, float* %44
%47 = fsub float %45, %46
%48 = tail call i64 @abs(float %47)
%49 = sitofp i64 %48 to float
%50 = load float, float* %26
%51 = fsub float %50, %49
store float %51, float* %26
%52 = getelementptr inbounds float, float* %33, i64 2
%53 = getelementptr inbounds float, float* %34, i64 2
%54 = add i32 %35, 2
%55 = icmp eq i32 %54, %20
br i1 %55, label %56, label %32
56: ; preds = %32, %31
%57 = phi float* [ undef, %31 ], [ %52, %32 ]
%58 = phi float* [ undef, %31 ], [ %53, %32 ]
%59 = phi float* [ %28, %31 ], [ %52, %32 ]
%60 = phi float* [ %29, %31 ], [ %53, %32 ]
br i1 %21, label %71, label %61
61: ; preds = %56
%62 = load float, float* %59
%63 = load float, float* %60
%64 = fsub float %62, %63
%65 = tail call i64 @abs(float %64)
%66 = sitofp i64 %65 to float
%67 = load float, float* %26
%68 = fsub float %67, %66
store float %68, float* %26
%69 = getelementptr inbounds float, float* %59, i64 1
%70 = getelementptr inbounds float, float* %60, i64 1
br label %71
71: ; preds = %61, %56, %27
%72 = phi float* [ %29, %27 ], [ %58, %56 ], [ %70, %61 ]
%73 = phi float* [ %28, %27 ], [ %57, %56 ], [ %69, %61 ]
%74 = getelementptr inbounds float, float* %72, i64 %13
%75 = getelementptr inbounds float, float* %74, i64 %15
%76 = getelementptr inbounds float, float* %73, i64 %13
%77 = getelementptr inbounds float, float* %76, i64 %15
%78 = add nuw nsw i32 %30, 1
%79 = icmp eq i32 %78, %2
br i1 %79, label %80, label %27
80: ; preds = %71, %22
%81 = add nuw nsw i64 %23, 1
%82 = icmp eq i64 %81, %17
br i1 %82, label %83, label %22
83: ; preds = %80
%84 = icmp slt i32 %5, 1
br i1 %84, label %154, label %85
85: ; preds = %83
%86 = getelementptr inbounds [64 x float], [64 x float]* %7, i64 0, i64 0
%87 = load float, float* %86
%88 = add nsw i64 %17, -1
%89 = add nsw i64 %17, -2
%90 = and i64 %88, 3
%91 = icmp ult i64 %89, 3
br i1 %91, label %129, label %92
92: ; preds = %85
%93 = and i64 %88, -4
br label %94
94: ; preds = %94, %92
%95 = phi i64 [ 1, %92 ], [ %126, %94 ]
%96 = phi i32 [ 0, %92 ], [ %125, %94 ]
%97 = phi float [ %87, %92 ], [ %123, %94 ]
%98 = phi i64 [ 0, %92 ], [ %127, %94 ]
%99 = getelementptr inbounds [64 x float], [64 x float]* %7, i64 0, i64 %95
%100 = load float, float* %99
%101 = fcmp olt float %97, %100
%102 = select i1 %101, float %100, float %97
%103 = trunc i64 %95 to i32
%104 = select i1 %101, i32 %103, i32 %96
%105 = add nuw nsw i64 %95, 1
%106 = getelementptr inbounds [64 x float], [64 x float]* %7, i64 0, i64 %105
%107 = load float, float* %106
%108 = fcmp olt float %102, %107
%109 = select i1 %108, float %107, float %102
%110 = trunc i64 %105 to i32
%111 = select i1 %108, i32 %110, i32 %104
%112 = add nuw nsw i64 %95, 2
%113 = getelementptr inbounds [64 x float], [64 x float]* %7, i64 0, i64 %112
%114 = load float, float* %113
%115 = fcmp olt float %109, %114
%116 = select i1 %115, float %114, float %109
%117 = trunc i64 %112 to i32
%118 = select i1 %115, i32 %117, i32 %111
%119 = add nuw nsw i64 %95, 3
%120 = getelementptr inbounds [64 x float], [64 x float]* %7, i64 0, i64 %119
%121 = load float, float* %120
%122 = fcmp olt float %116, %121
%123 = select i1 %122, float %121, float %116
%124 = trunc i64 %119 to i32
%125 = select i1 %122, i32 %124, i32 %118
%126 = add nuw nsw i64 %95, 4
%127 = add i64 %98, 4
%128 = icmp eq i64 %127, %93
br i1 %128, label %129, label %94
129: ; preds = %94, %85
%130 = phi i32 [ undef, %85 ], [ %125, %94 ]
%131 = phi i64 [ 1, %85 ], [ %126, %94 ]
%132 = phi i32 [ 0, %85 ], [ %125, %94 ]
%133 = phi float [ %87, %85 ], [ %123, %94 ]
%134 = icmp eq i64 %90, 0
br i1 %134, label %149, label %135
135: ; preds = %129, %135
%136 = phi i64 [ %146, %135 ], [ %131, %129 ]
%137 = phi i32 [ %145, %135 ], [ %132, %129 ]
%138 = phi float [ %143, %135 ], [ %133, %129 ]
%139 = phi i64 [ %147, %135 ], [ 0, %129 ]
%140 = getelementptr inbounds [64 x float], [64 x float]* %7, i64 0, i64 %136
%141 = load float, float* %140
%142 = fcmp olt float %138, %141
%143 = select i1 %142, float %141, float %138
%144 = trunc i64 %136 to i32
%145 = select i1 %142, i32 %144, i32 %137
%146 = add nuw nsw i64 %136, 1
%147 = add i64 %139, 1
%148 = icmp eq i64 %147, %90
br i1 %148, label %149, label %135
149: ; preds = %135, %129
%150 = phi i32 [ %130, %129 ], [ %145, %135 ]
%151 = icmp eq i32 %150, 0
%152 = icmp eq i32 %150, %5
%153 = or i1 %151, %152
br i1 %153, label %154, label %157
154: ; preds = %6, %83, %149
%155 = phi i32 [ %150, %149 ], [ 0, %83 ], [ 0, %6 ]
%156 = sitofp i32 %155 to float
br label %191
157: ; preds = %149
%158 = add nsw i32 %150, 1
%159 = sext i32 %158 to i64
%160 = getelementptr inbounds [64 x float], [64 x float]* %7, i64 0, i64 %159
%161 = load float, float* %160
%162 = add nsw i32 %150, -1
%163 = sext i32 %162 to i64
%164 = getelementptr inbounds [64 x float], [64 x float]* %7, i64 0, i64 %163
%165 = load float, float* %164
%166 = fadd float %161, %165
%167 = sext i32 %150 to i64
%168 = getelementptr inbounds [64 x float], [64 x float]* %7, i64 0, i64 %167
%169 = load float, float* %168
%170 = tail call float @llvm.fmuladd.f32(float %169, float -2.000000e+00, float %166)
%171 = fcmp oeq float %170, 0.000000e+00
br i1 %171, label %172, label %174
172: ; preds = %157
%173 = sitofp i32 %150 to float
br label %191
174: ; preds = %157
%175 = fsub float %161, %165
%176 = fpext float %175 to double
%177 = fmul double %176, -5.000000e-01
%178 = fpext float %170 to double
%179 = fdiv double %177, %178
%180 = fptrunc double %179 to float
%181 = fcmp ogt float %180, 1.000000e+00
%182 = fcmp olt float %180, -1.000000e+00
%183 = or i1 %181, %182
br i1 %183, label %184, label %188
184: ; preds = %174
%185 = load i32, i32* @stderr
%186 = tail call i32 @fprintf(i32 %185, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0))
%187 = sitofp i32 %150 to float
br label %191
188: ; preds = %174
%189 = sitofp i32 %150 to float
%190 = fadd float %189, %180
br label %191
191: ; preds = %188, %184, %172, %154
%192 = phi float [ %156, %154 ], [ %173, %172 ], [ %187, %184 ], [ %190, %188 ]
ret float %192
}