#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*/ memset(float *, int /*<<< orphan*/, int const);
float sobelGradient(const float *img, const int nx, const int ny, float *gx,
                    float *gy) {
  int y, yHi, xHi;
  float hi;
  const float *r0, *rp;
  for (y = 0; y < ny; y++) {
    int y0, y1;
    y0 = y * nx;
    y1 = y0 + nx - 1;
    gx[y0] = gx[y1] = gy[y0] = gy[y1] = 0.0f;
  }
  memset(gx, 0, nx * sizeof(float));
  memset(gy, 0, nx * sizeof(float));
  memset(gx + (y - 1) * nx, 0, nx * sizeof(float));
  memset(gy + (y - 1) * nx, 0, nx * sizeof(float));
  hi = 0;
  yHi = ny - 1;
  xHi = nx - 1;
  r0 = img;
  rp = r0 + nx;
  for (y = 1; y < yHi; y++) {
    const float *rm;
    float *rx, *ry;
    int x;
    rx = gx + y * nx;
    ry = gy + y * nx;
    rm = r0;
    r0 = rp;
    rp += nx;
    for (x = 1; x < xHi; x++) {
      float g;
      g = (float)(((double)rp[x + 1]) + ((double)rm[x + 1]) +
                  2 * (((double)r0[x + 1]) - ((double)r0[x - 1])) -
                  ((double)rp[x - 1]) - ((double)rm[x - 1]));
      rx[x] = g;
      if (g < 0)
        g = -g;
      if (g > hi)
        hi = g;
      g = (float)(((double)rp[x - 1]) + ((double)rp[x + 1]) +
                  2 * (((double)rp[x]) - ((double)rm[x])) -
                  ((double)rm[x - 1]) - ((double)rm[x + 1]));
      ry[x] = g;
      if (g < 0)
        g = -g;
      if (g > hi)
        hi = g;
    }
  }
  return (hi);
}


x86 assembly (clang, -O0):
<sobelGradient>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    11a1 <sobelGradient+0x91>
mov    -0x24(%rbp),%eax
imul   -0xc(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
add    -0xc(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x48(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x48(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1131 <sobelGradient+0x21>
mov    -0x18(%rbp),%rdi
movslq -0xc(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edx
xor    %esi,%esi
call   1030 <memset@plt>
mov    -0x20(%rbp),%rdi
movslq -0xc(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edx
xor    %esi,%esi
call   1030 <memset@plt>
mov    -0x18(%rbp),%rdi
mov    -0x24(%rbp),%eax
sub    $0x1,%eax
imul   -0xc(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
movslq -0xc(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edx
xor    %esi,%esi
call   1030 <memset@plt>
mov    -0x20(%rbp),%rdi
mov    -0x24(%rbp),%eax
sub    $0x1,%eax
imul   -0xc(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
movslq -0xc(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edx
xor    %esi,%esi
call   1030 <memset@plt>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x10(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
movslq -0xc(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    14d1 <sobelGradient+0x3c1>
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0xc(%rbp),%ecx
mov    -0x40(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
movl   $0x1,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    14be <sobelGradient+0x3ae>
mov    -0x40(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
mov    -0x50(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm0,%xmm1
mov    -0x38(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x38(%rbp),%rax
mov    -0x64(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
cvtss2sd %xmm2,%xmm2
subsd  %xmm2,%xmm0
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
mov    -0x64(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
subsd  %xmm1,%xmm0
mov    -0x50(%rbp),%rax
mov    -0x64(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x68(%rbp),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x64(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
xorps  %xmm0,%xmm0
ucomiss -0x68(%rbp),%xmm0
jbe    13a8 <sobelGradient+0x298>
movss  -0x68(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x68(%rbp),%xmm0
ucomiss -0x30(%rbp),%xmm0
jbe    13c1 <sobelGradient+0x2b1>
movss  -0x68(%rbp),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x64(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
mov    -0x40(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm0,%xmm1
mov    -0x40(%rbp),%rax
movslq -0x64(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x50(%rbp),%rax
movslq -0x64(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
cvtss2sd %xmm2,%xmm2
subsd  %xmm2,%xmm0
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
mov    -0x50(%rbp),%rax
mov    -0x64(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
subsd  %xmm1,%xmm0
mov    -0x50(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x68(%rbp),%xmm0
mov    -0x60(%rbp),%rax
movslq -0x64(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
xorps  %xmm0,%xmm0
ucomiss -0x68(%rbp),%xmm0
jbe    1492 <sobelGradient+0x382>
movss  -0x68(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x68(%rbp),%xmm0
ucomiss -0x30(%rbp),%xmm0
jbe    14ab <sobelGradient+0x39b>
movss  -0x68(%rbp),%xmm0
movss  %xmm0,-0x30(%rbp)
jmp    14b0 <sobelGradient+0x3a0>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    12c1 <sobelGradient+0x1b1>
jmp    14c3 <sobelGradient+0x3b3>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1257 <sobelGradient+0x147>
movss  -0x30(%rbp),%xmm0
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<sobelGradient>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %r8,%r13
mov    %rcx,%r12
mov    %rdi,%rbx
test   %edx,%edx
mov    %rdx,0x20(%rsp)
jle    1176 <sobelGradient+0x66>
lea    -0x1(%rsi),%eax
mov    %rax,0x8(%rsp)
movslq %esi,%rax
mov    %rax,(%rsp)
mov    %edx,%r10d
xor    %ebp,%ebp
cmp    $0x8,%edx
jb     12ca <sobelGradient+0x1ba>
cmp    $0x1,%esi
jne    12ca <sobelGradient+0x1ba>
lea    (%r12,%r10,4),%rcx
cmp    %r13,%rcx
jbe    1193 <sobelGradient+0x83>
lea    0x0(,%r10,4),%rcx
add    %r13,%rcx
cmp    %r12,%rcx
jbe    1193 <sobelGradient+0x83>
xor    %ebp,%ebp
jmp    12ca <sobelGradient+0x1ba>
movslq %esi,%rax
mov    %rax,(%rsp)
add    $0xffffffff,%eax
mov    %rax,0x8(%rsp)
mov    %rsi,%r15
mov    $0xffffffff,%r14d
jmp    13cc <sobelGradient+0x2bc>
mov    %r10d,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rcx
mov    %rcx,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
test   %rcx,%rcx
mov    %rax,0x18(%rsp)
mov    %rdi,0x10(%rsp)
je     15c9 <sobelGradient+0x4b9>
and    $0xfffffffffffffffe,%rdi
mov    (%rsp),%rax
mov    %rax,%rcx
shl    $0x5,%rcx
lea    (%r12,%rcx,1),%r11
add    $0x10,%r11
shl    $0x6,%rax
lea    (%rcx,%r13,1),%r14
add    $0x10,%r14
lea    (%rsi,%rsi,8),%ecx
add    $0xffffffff,%ecx
mov    %esi,%r15d
shl    $0x4,%r15d
xor    %r8d,%r8d
xorps  %xmm0,%xmm0
mov    0x8(%rsp),%r9
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movslq %r9d,%r9
movups %xmm0,0x0(%r13,%r9,4)
movups %xmm0,0x10(%r13,%r9,4)
movups %xmm0,0x0(%r13,%r8,1)
movups %xmm0,0x10(%r13,%r8,1)
movups %xmm0,(%r12,%r9,4)
movups %xmm0,0x10(%r12,%r9,4)
movups %xmm0,(%r12,%r8,1)
movups %xmm0,0x10(%r12,%r8,1)
movslq %ecx,%rcx
movups %xmm0,0x0(%r13,%rcx,4)
movups %xmm0,0x10(%r13,%rcx,4)
movups %xmm0,-0x10(%r14,%r8,1)
movups %xmm0,(%r14,%r8,1)
movups %xmm0,(%r12,%rcx,4)
movups %xmm0,0x10(%r12,%rcx,4)
movups %xmm0,-0x10(%r11,%r8,1)
movups %xmm0,(%r11,%r8,1)
add    $0x10,%rbp
add    %rax,%r8
add    %r15d,%ecx
add    %r15d,%r9d
add    $0xfffffffffffffffe,%rdi
jne    1200 <sobelGradient+0xf0>
testb  $0x1,0x10(%rsp)
je     12bc <sobelGradient+0x1ac>
imul   (%rsp),%rbp
mov    0x8(%rsp),%rax
lea    (%rax,%rbp,1),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movups %xmm0,0x0(%r13,%rcx,4)
movups %xmm0,0x10(%r13,%rcx,4)
movups %xmm0,0x0(%r13,%rbp,4)
movups %xmm0,0x10(%r13,%rbp,4)
movups %xmm0,(%r12,%rcx,4)
movups %xmm0,0x10(%r12,%rcx,4)
movups %xmm0,(%r12,%rbp,4)
movups %xmm0,0x10(%r12,%rbp,4)
mov    0x18(%rsp),%rbp
cmp    %r10,%rbp
je     13c5 <sobelGradient+0x2b5>
mov    %rbp,%rcx
not    %rcx
test   $0x1,%r10b
je     130d <sobelGradient+0x1fd>
mov    %rbp,%rdi
imul   (%rsp),%rdi
mov    0x8(%rsp),%rax
add    %edi,%eax
cltq
movl   $0x0,0x0(%r13,%rax,4)
movl   $0x0,0x0(%r13,%rdi,4)
movl   $0x0,(%r12,%rax,4)
movl   $0x0,(%r12,%rdi,4)
or     $0x1,%rbp
add    %r10,%rcx
je     13c5 <sobelGradient+0x2b5>
sub    %rbp,%r10
lea    0x1(%rbp),%edi
imul   %esi,%edi
add    $0xffffffff,%edi
lea    (%rsi,%rsi,1),%ecx
mov    %rbp,%rax
mov    (%rsp),%r11
imul   %r11,%rax
lea    0x0(,%rax,4),%r8
add    %r13,%r8
lea    0x0(,%r11,8),%r9
lea    (%r12,%rax,4),%r15
mov    %rbp,%rax
add    $0x1,%rax
imul   %r11,%rax
lea    (%r12,%rax,4),%r11
lea    0x0(,%rax,4),%r14
add    %r13,%r14
add    $0x2,%ebp
imul   %esi,%ebp
add    $0xffffffff,%ebp
xor    %eax,%eax
nopl   0x0(%rax)
movslq %edi,%rdi
movl   $0x0,0x0(%r13,%rdi,4)
movl   $0x0,(%r8,%rax,1)
movl   $0x0,(%r12,%rdi,4)
movl   $0x0,(%r15,%rax,1)
movslq %ebp,%rbp
movl   $0x0,0x0(%r13,%rbp,4)
movl   $0x0,(%r14,%rax,1)
movl   $0x0,(%r12,%rbp,4)
movl   $0x0,(%r11,%rax,1)
add    %ecx,%edi
add    %r9,%rax
add    %ecx,%ebp
add    $0xfffffffffffffffe,%r10
jne    1370 <sobelGradient+0x260>
mov    %rsi,%r15
lea    -0x1(%rdx),%r14d
lea    0x0(,%r15,4),%ebp
mov    %r12,%rdi
xor    %esi,%esi
mov    %ebp,%edx
call   1030 <memset@plt>
mov    %r13,%rdi
xor    %esi,%esi
mov    %ebp,%edx
call   1030 <memset@plt>
imul   %r15d,%r14d
movslq %r14d,%r14
lea    (%r12,%r14,4),%rdi
xor    %esi,%esi
mov    %ebp,%edx
call   1030 <memset@plt>
lea    0x0(,%r14,4),%rdi
add    %r13,%rdi
xor    %esi,%esi
mov    %ebp,%edx
call   1030 <memset@plt>
xorps  %xmm0,%xmm0
mov    0x20(%rsp),%r10
cmp    $0x3,%r10d
jl     15ba <sobelGradient+0x4aa>
add    $0xffffffff,%r10d
mov    (%rsp),%rdx
lea    (%rbx,%rdx,4),%rax
mov    0x8(%rsp),%ecx
lea    0x0(,%rdx,4),%r8
lea    (%rbx,%rdx,8),%rsi
add    $0x8,%rsi
lea    0x4(,%rdx,4),%rdi
add    %r13,%rdi
lea    (%r12,%rdx,4),%rbp
add    $0x4,%rbp
add    $0xffffffffffffffff,%rcx
xorps  %xmm1,%xmm1
mov    $0x1,%r9d
movaps 0xb93(%rip),%xmm2
xorps  %xmm0,%xmm0
jmp    149c <sobelGradient+0x38c>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r9
add    %r8,%rax
add    %r8,%rsi
add    %r8,%rbx
add    %r8,%rdi
add    %r8,%rbp
cmp    %r10,%r9
je     15ba <sobelGradient+0x4aa>
cmp    $0x3,%r15d
jl     1480 <sobelGradient+0x370>
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  -0x8(%rsi,%rdx,4),%xmm3
movss  (%rsi,%rdx,4),%xmm4
cvtss2sd %xmm4,%xmm4
movss  (%rbx,%rdx,4),%xmm5
movss  0x8(%rbx,%rdx,4),%xmm6
cvtss2sd %xmm6,%xmm6
addsd  %xmm4,%xmm6
movss  (%rax,%rdx,4),%xmm4
movss  0x8(%rax,%rdx,4),%xmm7
cvtss2sd %xmm7,%xmm7
cvtss2sd %xmm4,%xmm4
subsd  %xmm4,%xmm7
addsd  %xmm7,%xmm7
addsd  %xmm6,%xmm7
cvtss2sd %xmm3,%xmm3
subsd  %xmm3,%xmm7
xorps  %xmm3,%xmm3
cvtss2sd %xmm5,%xmm3
subsd  %xmm3,%xmm7
xorps  %xmm4,%xmm4
cvtsd2ss %xmm7,%xmm4
movss  %xmm4,0x0(%rbp,%rdx,4)
movaps %xmm4,%xmm5
xorps  %xmm2,%xmm5
movaps %xmm4,%xmm3
cmpltss %xmm1,%xmm3
andps  %xmm3,%xmm5
andnps %xmm4,%xmm3
orps   %xmm5,%xmm3
maxss  %xmm0,%xmm3
movss  -0x8(%rsi,%rdx,4),%xmm0
movss  -0x4(%rsi,%rdx,4),%xmm4
cvtss2sd %xmm0,%xmm0
movss  (%rsi,%rdx,4),%xmm5
cvtss2sd %xmm5,%xmm5
addsd  %xmm0,%xmm5
xorps  %xmm0,%xmm0
cvtss2sd %xmm4,%xmm0
movss  (%rbx,%rdx,4),%xmm4
movss  0x4(%rbx,%rdx,4),%xmm6
cvtss2sd %xmm6,%xmm6
subsd  %xmm6,%xmm0
addsd  %xmm0,%xmm0
addsd  %xmm5,%xmm0
cvtss2sd %xmm4,%xmm4
subsd  %xmm4,%xmm0
movss  0x8(%rbx,%rdx,4),%xmm4
cvtss2sd %xmm4,%xmm4
subsd  %xmm4,%xmm0
xorps  %xmm4,%xmm4
cvtsd2ss %xmm0,%xmm4
movss  %xmm4,(%rdi,%rdx,4)
movaps %xmm4,%xmm5
xorps  %xmm2,%xmm5
movaps %xmm4,%xmm0
cmpltss %xmm1,%xmm0
andps  %xmm0,%xmm5
andnps %xmm4,%xmm0
orps   %xmm5,%xmm0
maxss  %xmm3,%xmm0
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    14b0 <sobelGradient+0x3a0>
jmp    1480 <sobelGradient+0x370>
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %ebp,%ebp
testb  $0x1,0x10(%rsp)
jne    127b <sobelGradient+0x16b>
jmp    12bc <sobelGradient+0x1ac>

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

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