#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 */
float fabs(float);
void getneigh(short *neigh, float *J, int ny, int nx, int iy, int ix,
              short *rmap, unsigned char *rmap0, int loc) {
  float diff, neighJ = 100.0;
  int loc1;
  if (iy - 1 >= 0) {
    loc1 = loc - nx;
    if (rmap[loc1] > 0 && rmap0[loc] == rmap0[loc1]) {
      if (neigh[loc] > 0) {
        diff = fabs(J[loc] - J[loc1]);
        if (diff < neighJ) {
          neighJ = diff;
          if (neigh[loc] != rmap[loc1])
            neigh[loc] = rmap[loc1];
        }
      } else {
        neigh[loc] = rmap[loc1];
        neighJ = fabs(J[loc] - J[loc1]);
      }
    }
  }
  if (ix - 1 >= 0) {
    loc1 = loc - 1;
    if (rmap[loc1] > 0 && rmap0[loc] == rmap0[loc1]) {
      if (neigh[loc] > 0) {
        diff = fabs(J[loc] - J[loc1]);
        if (diff < neighJ) {
          neighJ = diff;
          if (neigh[loc] != rmap[loc1])
            neigh[loc] = rmap[loc1];
        }
      } else {
        neigh[loc] = rmap[loc1];
        neighJ = fabs(J[loc] - J[loc1]);
      }
    }
  }
  if (ix + 1 < nx) {
    loc1 = loc + 1;
    if (rmap[loc1] > 0 && rmap0[loc] == rmap0[loc1]) {
      if (neigh[loc] > 0) {
        diff = fabs(J[loc] - J[loc1]);
        if (diff < neighJ) {
          if (neigh[loc] != rmap[loc1])
            neigh[loc] = rmap[loc1];
        }
      } else {
        neigh[loc] = rmap[loc1];
        neighJ = fabs(J[loc] - J[loc1]);
      }
    }
  }
  if (iy + 1 < ny) {
    loc1 = loc + nx;
    if (rmap[loc1] > 0 && rmap0[loc] == rmap0[loc1]) {
      if (neigh[loc] > 0) {
        diff = fabs(J[loc] - J[loc1]);
        if (diff < neighJ) {
          neighJ = diff;
          if (neigh[loc] != rmap[loc1])
            neigh[loc] = rmap[loc1];
        }
      } else {
        neigh[loc] = rmap[loc1];
        neighJ = fabs(J[loc] - J[loc1]);
      }
    }
  }
}


x86 assembly (clang, -O0):
<getneigh>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
mov    %r9d,-0x20(%rbp)
movss  0xebf(%rip),%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
cmp    $0x0,%eax
jl     1271 <getneigh+0x161>
mov    0x20(%rbp),%eax
sub    -0x18(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
cmp    $0x0,%eax
jle    126c <getneigh+0x15c>
mov    0x18(%rbp),%rax
movslq 0x20(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    0x18(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jne    126c <getneigh+0x15c>
mov    -0x8(%rbp),%rax
movslq 0x20(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
cmp    $0x0,%eax
jle    122b <getneigh+0x11b>
mov    -0x10(%rbp),%rax
movslq 0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
call   1030 <fabs@plt>
movss  %xmm0,-0x24(%rbp)
movss  -0x24(%rbp),%xmm1
movss  -0x28(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1226 <getneigh+0x116>
movss  -0x24(%rbp),%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x8(%rbp),%rax
movslq 0x20(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
mov    0x10(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
movswl (%rcx,%rdx,2),%ecx
cmp    %ecx,%eax
je     1221 <getneigh+0x111>
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,2),%dx
mov    -0x8(%rbp),%rax
movslq 0x20(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
jmp    1226 <getneigh+0x116>
jmp    1267 <getneigh+0x157>
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,2),%dx
mov    -0x8(%rbp),%rax
movslq 0x20(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x10(%rbp),%rax
movslq 0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
call   1030 <fabs@plt>
movss  %xmm0,-0x28(%rbp)
jmp    126c <getneigh+0x15c>
jmp    1271 <getneigh+0x161>
mov    -0x20(%rbp),%eax
sub    $0x1,%eax
cmp    $0x0,%eax
jl     139c <getneigh+0x28c>
mov    0x20(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
cmp    $0x0,%eax
jle    1397 <getneigh+0x287>
mov    0x18(%rbp),%rax
movslq 0x20(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    0x18(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jne    1397 <getneigh+0x287>
mov    -0x8(%rbp),%rax
movslq 0x20(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
cmp    $0x0,%eax
jle    1356 <getneigh+0x246>
mov    -0x10(%rbp),%rax
movslq 0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
call   1030 <fabs@plt>
movss  %xmm0,-0x24(%rbp)
movss  -0x24(%rbp),%xmm1
movss  -0x28(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1351 <getneigh+0x241>
movss  -0x24(%rbp),%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x8(%rbp),%rax
movslq 0x20(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
mov    0x10(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
movswl (%rcx,%rdx,2),%ecx
cmp    %ecx,%eax
je     134c <getneigh+0x23c>
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,2),%dx
mov    -0x8(%rbp),%rax
movslq 0x20(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
jmp    1351 <getneigh+0x241>
jmp    1392 <getneigh+0x282>
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,2),%dx
mov    -0x8(%rbp),%rax
movslq 0x20(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x10(%rbp),%rax
movslq 0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
call   1030 <fabs@plt>
movss  %xmm0,-0x28(%rbp)
jmp    1397 <getneigh+0x287>
jmp    139c <getneigh+0x28c>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
cmp    -0x18(%rbp),%eax
jge    14bd <getneigh+0x3ad>
mov    0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
cmp    $0x0,%eax
jle    14b8 <getneigh+0x3a8>
mov    0x18(%rbp),%rax
movslq 0x20(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    0x18(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jne    14b8 <getneigh+0x3a8>
mov    -0x8(%rbp),%rax
movslq 0x20(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
cmp    $0x0,%eax
jle    1477 <getneigh+0x367>
mov    -0x10(%rbp),%rax
movslq 0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
call   1030 <fabs@plt>
movss  %xmm0,-0x24(%rbp)
movss  -0x24(%rbp),%xmm1
movss  -0x28(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1472 <getneigh+0x362>
mov    -0x8(%rbp),%rax
movslq 0x20(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
mov    0x10(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
movswl (%rcx,%rdx,2),%ecx
cmp    %ecx,%eax
je     146d <getneigh+0x35d>
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,2),%dx
mov    -0x8(%rbp),%rax
movslq 0x20(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
jmp    1472 <getneigh+0x362>
jmp    14b3 <getneigh+0x3a3>
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,2),%dx
mov    -0x8(%rbp),%rax
movslq 0x20(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x10(%rbp),%rax
movslq 0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
call   1030 <fabs@plt>
movss  %xmm0,-0x28(%rbp)
jmp    14b8 <getneigh+0x3a8>
jmp    14bd <getneigh+0x3ad>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
cmp    -0x14(%rbp),%eax
jge    15e8 <getneigh+0x4d8>
mov    0x20(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
cmp    $0x0,%eax
jle    15e3 <getneigh+0x4d3>
mov    0x18(%rbp),%rax
movslq 0x20(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    0x18(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jne    15e3 <getneigh+0x4d3>
mov    -0x8(%rbp),%rax
movslq 0x20(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
cmp    $0x0,%eax
jle    15a2 <getneigh+0x492>
mov    -0x10(%rbp),%rax
movslq 0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
call   1030 <fabs@plt>
movss  %xmm0,-0x24(%rbp)
movss  -0x24(%rbp),%xmm1
movss  -0x28(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    159d <getneigh+0x48d>
movss  -0x24(%rbp),%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x8(%rbp),%rax
movslq 0x20(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
mov    0x10(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
movswl (%rcx,%rdx,2),%ecx
cmp    %ecx,%eax
je     1598 <getneigh+0x488>
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,2),%dx
mov    -0x8(%rbp),%rax
movslq 0x20(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
jmp    159d <getneigh+0x48d>
jmp    15de <getneigh+0x4ce>
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,2),%dx
mov    -0x8(%rbp),%rax
movslq 0x20(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x10(%rbp),%rax
movslq 0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
call   1030 <fabs@plt>
movss  %xmm0,-0x28(%rbp)
jmp    15e3 <getneigh+0x4d3>
jmp    15e8 <getneigh+0x4d8>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<getneigh>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
mov    0x40(%rsp),%r14d
mov    0x38(%rsp),%r10
mov    0x30(%rsp),%r11
movss  0xee1(%rip),%xmm0
test   %r8d,%r8d
jle    1194 <getneigh+0x94>
mov    %r14d,%eax
sub    %ecx,%eax
movslq %eax,%rbp
movzwl (%r11,%rbp,2),%ebx
test   %bx,%bx
jle    1194 <getneigh+0x94>
movslq %r14d,%r12
mov    (%r10,%r12,1),%al
cmp    (%r10,%rbp,1),%al
jne    1194 <getneigh+0x94>
movzwl (%rdi,%r12,2),%r15d
test   %r15w,%r15w
jle    117d <getneigh+0x7d>
movss  (%rsi,%r12,4),%xmm1
subss  (%rsi,%rbp,4),%xmm1
andps  0xeb0(%rip),%xmm1
movss  0xe98(%rip),%xmm0
ucomiss %xmm1,%xmm0
jbe    1194 <getneigh+0x94>
movaps %xmm1,%xmm0
cmp    %bx,%r15w
je     1194 <getneigh+0x94>
mov    %bx,(%rdi,%r12,2)
jmp    1194 <getneigh+0x94>
mov    %bx,(%rdi,%r12,2)
movss  (%rsi,%r12,4),%xmm0
subss  (%rsi,%rbp,4),%xmm0
andps  0xe7c(%rip),%xmm0
test   %r9d,%r9d
jle    11f6 <getneigh+0xf6>
movslq %r14d,%rbx
movzwl -0x2(%r11,%rbx,2),%ebp
test   %bp,%bp
jle    11f6 <getneigh+0xf6>
mov    (%r10,%rbx,1),%al
cmp    -0x1(%r10,%rbx,1),%al
jne    11f6 <getneigh+0xf6>
movzwl (%rdi,%rbx,2),%eax
test   %ax,%ax
jle    11e0 <getneigh+0xe0>
movss  (%rsi,%rbx,4),%xmm1
subss  -0x4(%rsi,%rbx,4),%xmm1
andps  0xe43(%rip),%xmm1
ucomiss %xmm1,%xmm0
jbe    11f6 <getneigh+0xf6>
movaps %xmm1,%xmm0
cmp    %bp,%ax
je     11f6 <getneigh+0xf6>
mov    %bp,(%rdi,%rbx,2)
jmp    11f6 <getneigh+0xf6>
mov    %bp,(%rdi,%rbx,2)
movss  (%rsi,%rbx,4),%xmm0
subss  -0x4(%rsi,%rbx,4),%xmm0
andps  0xe1a(%rip),%xmm0
add    $0x1,%r9d
cmp    %ecx,%r9d
jge    1259 <getneigh+0x159>
movslq %r14d,%rax
movzwl 0x2(%r11,%rax,2),%ebp
test   %bp,%bp
jle    1259 <getneigh+0x159>
mov    (%r10,%rax,1),%bl
cmp    0x1(%r10,%rax,1),%bl
jne    1259 <getneigh+0x159>
movzwl (%rdi,%rax,2),%ebx
test   %bx,%bx
jle    1243 <getneigh+0x143>
movss  (%rsi,%rax,4),%xmm1
subss  0x4(%rsi,%rax,4),%xmm1
andps  0xddd(%rip),%xmm1
ucomiss %xmm1,%xmm0
jbe    1259 <getneigh+0x159>
cmp    %bp,%bx
je     1259 <getneigh+0x159>
mov    %bp,(%rdi,%rax,2)
jmp    1259 <getneigh+0x159>
mov    %bp,(%rdi,%rax,2)
movss  (%rsi,%rax,4),%xmm0
subss  0x4(%rsi,%rax,4),%xmm0
andps  0xdb7(%rip),%xmm0
add    $0x1,%r8d
cmp    %edx,%r8d
jge    12a7 <getneigh+0x1a7>
add    %r14d,%ecx
movslq %ecx,%rdx
movzwl (%r11,%rdx,2),%eax
test   %ax,%ax
jle    12a7 <getneigh+0x1a7>
movslq %r14d,%rcx
mov    (%r10,%rcx,1),%bl
cmp    (%r10,%rdx,1),%bl
jne    12a7 <getneigh+0x1a7>
movzwl (%rdi,%rcx,2),%ebp
test   %bp,%bp
jle    12a3 <getneigh+0x1a3>
movss  (%rsi,%rcx,4),%xmm1
subss  (%rsi,%rdx,4),%xmm1
andps  0xd77(%rip),%xmm1
ucomiss %xmm1,%xmm0
jbe    12a7 <getneigh+0x1a7>
cmp    %ax,%bp
je     12a7 <getneigh+0x1a7>
mov    %ax,(%rdi,%rcx,2)
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @getneigh(i16* %0, float* %1, i32 %2, i32 %3, i32 %4, i32 %5, i16* %6, i8* %7, i32 %8) {
%10 = alloca i16*
%11 = alloca float*
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i16*
%17 = alloca i8*
%18 = alloca i32
%19 = alloca float
%20 = alloca float
%21 = alloca i32
store i16* %0, i16** %10
store float* %1, float** %11
store i32 %2, i32* %12
store i32 %3, i32* %13
store i32 %4, i32* %14
store i32 %5, i32* %15
store i16* %6, i16** %16
store i8* %7, i8** %17
store i32 %8, i32* %18
store float 1.000000e+02, float* %20
%22 = load i32, i32* %14
%23 = sub nsw i32 %22, 1
%24 = icmp sge i32 %23, 0
br i1 %24, label %25, label %125
25: ; preds = %9
%26 = load i32, i32* %18
%27 = load i32, i32* %13
%28 = sub nsw i32 %26, %27
store i32 %28, i32* %21
%29 = load i16*, i16** %16
%30 = load i32, i32* %21
%31 = sext i32 %30 to i64
%32 = getelementptr inbounds i16, i16* %29, i64 %31
%33 = load i16, i16* %32
%34 = sext i16 %33 to i32
%35 = icmp sgt i32 %34, 0
br i1 %35, label %36, label %124
36: ; preds = %25
%37 = load i8*, i8** %17
%38 = load i32, i32* %18
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds i8, i8* %37, i64 %39
%41 = load i8, i8* %40
%42 = zext i8 %41 to i32
%43 = load i8*, i8** %17
%44 = load i32, i32* %21
%45 = sext i32 %44 to i64
%46 = getelementptr inbounds i8, i8* %43, i64 %45
%47 = load i8, i8* %46
%48 = zext i8 %47 to i32
%49 = icmp eq i32 %42, %48
br i1 %49, label %50, label %124
50: ; preds = %36
%51 = load i16*, i16** %10
%52 = load i32, i32* %18
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds i16, i16* %51, i64 %53
%55 = load i16, i16* %54
%56 = sext i16 %55 to i32
%57 = icmp sgt i32 %56, 0
br i1 %57, label %58, label %101
58: ; preds = %50
%59 = load float*, float** %11
%60 = load i32, i32* %18
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds float, float* %59, i64 %61
%63 = load float, float* %62
%64 = load float*, float** %11
%65 = load i32, i32* %21
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds float, float* %64, i64 %66
%68 = load float, float* %67
%69 = fsub float %63, %68
%70 = call float @fabs(float %69)
store float %70, float* %19
%71 = load float, float* %19
%72 = load float, float* %20
%73 = fcmp olt float %71, %72
br i1 %73, label %74, label %100
74: ; preds = %58
%75 = load float, float* %19
store float %75, float* %20
%76 = load i16*, i16** %10
%77 = load i32, i32* %18
%78 = sext i32 %77 to i64
%79 = getelementptr inbounds i16, i16* %76, i64 %78
%80 = load i16, i16* %79
%81 = sext i16 %80 to i32
%82 = load i16*, i16** %16
%83 = load i32, i32* %21
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds i16, i16* %82, i64 %84
%86 = load i16, i16* %85
%87 = sext i16 %86 to i32
%88 = icmp ne i32 %81, %87
br i1 %88, label %89, label %99
89: ; preds = %74
%90 = load i16*, i16** %16
%91 = load i32, i32* %21
%92 = sext i32 %91 to i64
%93 = getelementptr inbounds i16, i16* %90, i64 %92
%94 = load i16, i16* %93
%95 = load i16*, i16** %10
%96 = load i32, i32* %18
%97 = sext i32 %96 to i64
%98 = getelementptr inbounds i16, i16* %95, i64 %97
store i16 %94, i16* %98
br label %99
99: ; preds = %89, %74
br label %100
100: ; preds = %99, %58
br label %123
101: ; preds = %50
%102 = load i16*, i16** %16
%103 = load i32, i32* %21
%104 = sext i32 %103 to i64
%105 = getelementptr inbounds i16, i16* %102, i64 %104
%106 = load i16, i16* %105
%107 = load i16*, i16** %10
%108 = load i32, i32* %18
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds i16, i16* %107, i64 %109
store i16 %106, i16* %110
%111 = load float*, float** %11
%112 = load i32, i32* %18
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds float, float* %111, i64 %113
%115 = load float, float* %114
%116 = load float*, float** %11
%117 = load i32, i32* %21
%118 = sext i32 %117 to i64
%119 = getelementptr inbounds float, float* %116, i64 %118
%120 = load float, float* %119
%121 = fsub float %115, %120
%122 = call float @fabs(float %121)
store float %122, float* %20
br label %123
123: ; preds = %101, %100
br label %124
124: ; preds = %123, %36, %25
br label %125
125: ; preds = %124, %9
%126 = load i32, i32* %15
%127 = sub nsw i32 %126, 1
%128 = icmp sge i32 %127, 0
br i1 %128, label %129, label %228
129: ; preds = %125
%130 = load i32, i32* %18
%131 = sub nsw i32 %130, 1
store i32 %131, i32* %21
%132 = load i16*, i16** %16
%133 = load i32, i32* %21
%134 = sext i32 %133 to i64
%135 = getelementptr inbounds i16, i16* %132, i64 %134
%136 = load i16, i16* %135
%137 = sext i16 %136 to i32
%138 = icmp sgt i32 %137, 0
br i1 %138, label %139, label %227
139: ; preds = %129
%140 = load i8*, i8** %17
%141 = load i32, i32* %18
%142 = sext i32 %141 to i64
%143 = getelementptr inbounds i8, i8* %140, i64 %142
%144 = load i8, i8* %143
%145 = zext i8 %144 to i32
%146 = load i8*, i8** %17
%147 = load i32, i32* %21
%148 = sext i32 %147 to i64
%149 = getelementptr inbounds i8, i8* %146, i64 %148
%150 = load i8, i8* %149
%151 = zext i8 %150 to i32
%152 = icmp eq i32 %145, %151
br i1 %152, label %153, label %227
153: ; preds = %139
%154 = load i16*, i16** %10
%155 = load i32, i32* %18
%156 = sext i32 %155 to i64
%157 = getelementptr inbounds i16, i16* %154, i64 %156
%158 = load i16, i16* %157
%159 = sext i16 %158 to i32
%160 = icmp sgt i32 %159, 0
br i1 %160, label %161, label %204
161: ; preds = %153
%162 = load float*, float** %11
%163 = load i32, i32* %18
%164 = sext i32 %163 to i64
%165 = getelementptr inbounds float, float* %162, i64 %164
%166 = load float, float* %165
%167 = load float*, float** %11
%168 = load i32, i32* %21
%169 = sext i32 %168 to i64
%170 = getelementptr inbounds float, float* %167, i64 %169
%171 = load float, float* %170
%172 = fsub float %166, %171
%173 = call float @fabs(float %172)
store float %173, float* %19
%174 = load float, float* %19
%175 = load float, float* %20
%176 = fcmp olt float %174, %175
br i1 %176, label %177, label %203
177: ; preds = %161
%178 = load float, float* %19
store float %178, float* %20
%179 = load i16*, i16** %10
%180 = load i32, i32* %18
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds i16, i16* %179, i64 %181
%183 = load i16, i16* %182
%184 = sext i16 %183 to i32
%185 = load i16*, i16** %16
%186 = load i32, i32* %21
%187 = sext i32 %186 to i64
%188 = getelementptr inbounds i16, i16* %185, i64 %187
%189 = load i16, i16* %188
%190 = sext i16 %189 to i32
%191 = icmp ne i32 %184, %190
br i1 %191, label %192, label %202
192: ; preds = %177
%193 = load i16*, i16** %16
%194 = load i32, i32* %21
%195 = sext i32 %194 to i64
%196 = getelementptr inbounds i16, i16* %193, i64 %195
%197 = load i16, i16* %196
%198 = load i16*, i16** %10
%199 = load i32, i32* %18
%200 = sext i32 %199 to i64
%201 = getelementptr inbounds i16, i16* %198, i64 %200
store i16 %197, i16* %201
br label %202
202: ; preds = %192, %177
br label %203
203: ; preds = %202, %161
br label %226
204: ; preds = %153
%205 = load i16*, i16** %16
%206 = load i32, i32* %21
%207 = sext i32 %206 to i64
%208 = getelementptr inbounds i16, i16* %205, i64 %207
%209 = load i16, i16* %208
%210 = load i16*, i16** %10
%211 = load i32, i32* %18
%212 = sext i32 %211 to i64
%213 = getelementptr inbounds i16, i16* %210, i64 %212
store i16 %209, i16* %213
%214 = load float*, float** %11
%215 = load i32, i32* %18
%216 = sext i32 %215 to i64
%217 = getelementptr inbounds float, float* %214, i64 %216
%218 = load float, float* %217
%219 = load float*, float** %11
%220 = load i32, i32* %21
%221 = sext i32 %220 to i64
%222 = getelementptr inbounds float, float* %219, i64 %221
%223 = load float, float* %222
%224 = fsub float %218, %223
%225 = call float @fabs(float %224)
store float %225, float* %20
br label %226
226: ; preds = %204, %203
br label %227
227: ; preds = %226, %139, %129
br label %228
228: ; preds = %227, %125
%229 = load i32, i32* %15
%230 = add nsw i32 %229, 1
%231 = load i32, i32* %13
%232 = icmp slt i32 %230, %231
br i1 %232, label %233, label %331
233: ; preds = %228
%234 = load i32, i32* %18
%235 = add nsw i32 %234, 1
store i32 %235, i32* %21
%236 = load i16*, i16** %16
%237 = load i32, i32* %21
%238 = sext i32 %237 to i64
%239 = getelementptr inbounds i16, i16* %236, i64 %238
%240 = load i16, i16* %239
%241 = sext i16 %240 to i32
%242 = icmp sgt i32 %241, 0
br i1 %242, label %243, label %330
243: ; preds = %233
%244 = load i8*, i8** %17
%245 = load i32, i32* %18
%246 = sext i32 %245 to i64
%247 = getelementptr inbounds i8, i8* %244, i64 %246
%248 = load i8, i8* %247
%249 = zext i8 %248 to i32
%250 = load i8*, i8** %17
%251 = load i32, i32* %21
%252 = sext i32 %251 to i64
%253 = getelementptr inbounds i8, i8* %250, i64 %252
%254 = load i8, i8* %253
%255 = zext i8 %254 to i32
%256 = icmp eq i32 %249, %255
br i1 %256, label %257, label %330
257: ; preds = %243
%258 = load i16*, i16** %10
%259 = load i32, i32* %18
%260 = sext i32 %259 to i64
%261 = getelementptr inbounds i16, i16* %258, i64 %260
%262 = load i16, i16* %261
%263 = sext i16 %262 to i32
%264 = icmp sgt i32 %263, 0
br i1 %264, label %265, label %307
265: ; preds = %257
%266 = load float*, float** %11
%267 = load i32, i32* %18
%268 = sext i32 %267 to i64
%269 = getelementptr inbounds float, float* %266, i64 %268
%270 = load float, float* %269
%271 = load float*, float** %11
%272 = load i32, i32* %21
%273 = sext i32 %272 to i64
%274 = getelementptr inbounds float, float* %271, i64 %273
%275 = load float, float* %274
%276 = fsub float %270, %275
%277 = call float @fabs(float %276)
store float %277, float* %19
%278 = load float, float* %19
%279 = load float, float* %20
%280 = fcmp olt float %278, %279
br i1 %280, label %281, label %306
281: ; preds = %265
%282 = load i16*, i16** %10
%283 = load i32, i32* %18
%284 = sext i32 %283 to i64
%285 = getelementptr inbounds i16, i16* %282, i64 %284
%286 = load i16, i16* %285
%287 = sext i16 %286 to i32
%288 = load i16*, i16** %16
%289 = load i32, i32* %21
%290 = sext i32 %289 to i64
%291 = getelementptr inbounds i16, i16* %288, i64 %290
%292 = load i16, i16* %291
%293 = sext i16 %292 to i32
%294 = icmp ne i32 %287, %293
br i1 %294, label %295, label %305
295: ; preds = %281
%296 = load i16*, i16** %16
%297 = load i32, i32* %21
%298 = sext i32 %297 to i64
%299 = getelementptr inbounds i16, i16* %296, i64 %298
%300 = load i16, i16* %299
%301 = load i16*, i16** %10
%302 = load i32, i32* %18
%303 = sext i32 %302 to i64
%304 = getelementptr inbounds i16, i16* %301, i64 %303
store i16 %300, i16* %304
br label %305
305: ; preds = %295, %281
br label %306
306: ; preds = %305, %265
br label %329
307: ; preds = %257
%308 = load i16*, i16** %16
%309 = load i32, i32* %21
%310 = sext i32 %309 to i64
%311 = getelementptr inbounds i16, i16* %308, i64 %310
%312 = load i16, i16* %311
%313 = load i16*, i16** %10
%314 = load i32, i32* %18
%315 = sext i32 %314 to i64
%316 = getelementptr inbounds i16, i16* %313, i64 %315
store i16 %312, i16* %316
%317 = load float*, float** %11
%318 = load i32, i32* %18
%319 = sext i32 %318 to i64
%320 = getelementptr inbounds float, float* %317, i64 %319
%321 = load float, float* %320
%322 = load float*, float** %11
%323 = load i32, i32* %21
%324 = sext i32 %323 to i64
%325 = getelementptr inbounds float, float* %322, i64 %324
%326 = load float, float* %325
%327 = fsub float %321, %326
%328 = call float @fabs(float %327)
store float %328, float* %20
br label %329
329: ; preds = %307, %306
br label %330
330: ; preds = %329, %243, %233
br label %331
331: ; preds = %330, %228
%332 = load i32, i32* %14
%333 = add nsw i32 %332, 1
%334 = load i32, i32* %12
%335 = icmp slt i32 %333, %334
br i1 %335, label %336, label %436
336: ; preds = %331
%337 = load i32, i32* %18
%338 = load i32, i32* %13
%339 = add nsw i32 %337, %338
store i32 %339, i32* %21
%340 = load i16*, i16** %16
%341 = load i32, i32* %21
%342 = sext i32 %341 to i64
%343 = getelementptr inbounds i16, i16* %340, i64 %342
%344 = load i16, i16* %343
%345 = sext i16 %344 to i32
%346 = icmp sgt i32 %345, 0
br i1 %346, label %347, label %435
347: ; preds = %336
%348 = load i8*, i8** %17
%349 = load i32, i32* %18
%350 = sext i32 %349 to i64
%351 = getelementptr inbounds i8, i8* %348, i64 %350
%352 = load i8, i8* %351
%353 = zext i8 %352 to i32
%354 = load i8*, i8** %17
%355 = load i32, i32* %21
%356 = sext i32 %355 to i64
%357 = getelementptr inbounds i8, i8* %354, i64 %356
%358 = load i8, i8* %357
%359 = zext i8 %358 to i32
%360 = icmp eq i32 %353, %359
br i1 %360, label %361, label %435
361: ; preds = %347
%362 = load i16*, i16** %10
%363 = load i32, i32* %18
%364 = sext i32 %363 to i64
%365 = getelementptr inbounds i16, i16* %362, i64 %364
%366 = load i16, i16* %365
%367 = sext i16 %366 to i32
%368 = icmp sgt i32 %367, 0
br i1 %368, label %369, label %412
369: ; preds = %361
%370 = load float*, float** %11
%371 = load i32, i32* %18
%372 = sext i32 %371 to i64
%373 = getelementptr inbounds float, float* %370, i64 %372
%374 = load float, float* %373
%375 = load float*, float** %11
%376 = load i32, i32* %21
%377 = sext i32 %376 to i64
%378 = getelementptr inbounds float, float* %375, i64 %377
%379 = load float, float* %378
%380 = fsub float %374, %379
%381 = call float @fabs(float %380)
store float %381, float* %19
%382 = load float, float* %19
%383 = load float, float* %20
%384 = fcmp olt float %382, %383
br i1 %384, label %385, label %411
385: ; preds = %369
%386 = load float, float* %19
store float %386, float* %20
%387 = load i16*, i16** %10
%388 = load i32, i32* %18
%389 = sext i32 %388 to i64
%390 = getelementptr inbounds i16, i16* %387, i64 %389
%391 = load i16, i16* %390
%392 = sext i16 %391 to i32
%393 = load i16*, i16** %16
%394 = load i32, i32* %21
%395 = sext i32 %394 to i64
%396 = getelementptr inbounds i16, i16* %393, i64 %395
%397 = load i16, i16* %396
%398 = sext i16 %397 to i32
%399 = icmp ne i32 %392, %398
br i1 %399, label %400, label %410
400: ; preds = %385
%401 = load i16*, i16** %16
%402 = load i32, i32* %21
%403 = sext i32 %402 to i64
%404 = getelementptr inbounds i16, i16* %401, i64 %403
%405 = load i16, i16* %404
%406 = load i16*, i16** %10
%407 = load i32, i32* %18
%408 = sext i32 %407 to i64
%409 = getelementptr inbounds i16, i16* %406, i64 %408
store i16 %405, i16* %409
br label %410
410: ; preds = %400, %385
br label %411
411: ; preds = %410, %369
br label %434
412: ; preds = %361
%413 = load i16*, i16** %16
%414 = load i32, i32* %21
%415 = sext i32 %414 to i64
%416 = getelementptr inbounds i16, i16* %413, i64 %415
%417 = load i16, i16* %416
%418 = load i16*, i16** %10
%419 = load i32, i32* %18
%420 = sext i32 %419 to i64
%421 = getelementptr inbounds i16, i16* %418, i64 %420
store i16 %417, i16* %421
%422 = load float*, float** %11
%423 = load i32, i32* %18
%424 = sext i32 %423 to i64
%425 = getelementptr inbounds float, float* %422, i64 %424
%426 = load float, float* %425
%427 = load float*, float** %11
%428 = load i32, i32* %21
%429 = sext i32 %428 to i64
%430 = getelementptr inbounds float, float* %427, i64 %429
%431 = load float, float* %430
%432 = fsub float %426, %431
%433 = call float @fabs(float %432)
store float %433, float* %20
br label %434
434: ; preds = %412, %411
br label %435
435: ; preds = %434, %347, %336
br label %436
436: ; preds = %435, %331
ret void
}

LLVM IR (-O2):
define void @getneigh(i16* nocapture %0, float* nocapture %1, i32 %2, i32 %3, i32 %4, i32 %5, i16* nocapture %6, i8* nocapture %7, i32 %8) {
%10 = icmp sgt i32 %4, 0
br i1 %10, label %11, label %46
11: ; preds = %9
%12 = sub nsw i32 %8, %3
%13 = sext i32 %12 to i64
%14 = getelementptr inbounds i16, i16* %6, i64 %13
%15 = load i16, i16* %14
%16 = icmp sgt i16 %15, 0
br i1 %16, label %17, label %46
17: ; preds = %11
%18 = sext i32 %8 to i64
%19 = getelementptr inbounds i8, i8* %7, i64 %18
%20 = load i8, i8* %19
%21 = getelementptr inbounds i8, i8* %7, i64 %13
%22 = load i8, i8* %21
%23 = icmp eq i8 %20, %22
br i1 %23, label %24, label %46
24: ; preds = %17
%25 = getelementptr inbounds i16, i16* %0, i64 %18
%26 = load i16, i16* %25
%27 = icmp sgt i16 %26, 0
br i1 %27, label %28, label %39
28: ; preds = %24
%29 = getelementptr inbounds float, float* %1, i64 %18
%30 = load float, float* %29
%31 = getelementptr inbounds float, float* %1, i64 %13
%32 = load float, float* %31
%33 = fsub float %30, %32
%34 = tail call float @llvm.fabs.f32(float %33)
%35 = fcmp olt float %34, 1.000000e+02
br i1 %35, label %36, label %46
36: ; preds = %28
%37 = icmp eq i16 %26, %15
br i1 %37, label %46, label %38
38: ; preds = %36
store i16 %15, i16* %25
br label %46
39: ; preds = %24
store i16 %15, i16* %25
%40 = getelementptr inbounds float, float* %1, i64 %18
%41 = load float, float* %40
%42 = getelementptr inbounds float, float* %1, i64 %13
%43 = load float, float* %42
%44 = fsub float %41, %43
%45 = tail call float @llvm.fabs.f32(float %44)
br label %46
46: ; preds = %11, %17, %28, %38, %36, %39, %9
%47 = phi float [ %34, %38 ], [ %34, %36 ], [ 1.000000e+02, %28 ], [ %45, %39 ], [ 1.000000e+02, %17 ], [ 1.000000e+02, %11 ], [ 1.000000e+02, %9 ]
%48 = icmp sgt i32 %5, 0
br i1 %48, label %49, label %84
49: ; preds = %46
%50 = add nsw i32 %8, -1
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds i16, i16* %6, i64 %51
%53 = load i16, i16* %52
%54 = icmp sgt i16 %53, 0
br i1 %54, label %55, label %84
55: ; preds = %49
%56 = sext i32 %8 to i64
%57 = getelementptr inbounds i8, i8* %7, i64 %56
%58 = load i8, i8* %57
%59 = getelementptr inbounds i8, i8* %7, i64 %51
%60 = load i8, i8* %59
%61 = icmp eq i8 %58, %60
br i1 %61, label %62, label %84
62: ; preds = %55
%63 = getelementptr inbounds i16, i16* %0, i64 %56
%64 = load i16, i16* %63
%65 = icmp sgt i16 %64, 0
br i1 %65, label %66, label %77
66: ; preds = %62
%67 = getelementptr inbounds float, float* %1, i64 %56
%68 = load float, float* %67
%69 = getelementptr inbounds float, float* %1, i64 %51
%70 = load float, float* %69
%71 = fsub float %68, %70
%72 = tail call float @llvm.fabs.f32(float %71)
%73 = fcmp olt float %72, %47
br i1 %73, label %74, label %84
74: ; preds = %66
%75 = icmp eq i16 %64, %53
br i1 %75, label %84, label %76
76: ; preds = %74
store i16 %53, i16* %63
br label %84
77: ; preds = %62
store i16 %53, i16* %63
%78 = getelementptr inbounds float, float* %1, i64 %56
%79 = load float, float* %78
%80 = getelementptr inbounds float, float* %1, i64 %51
%81 = load float, float* %80
%82 = fsub float %79, %81
%83 = tail call float @llvm.fabs.f32(float %82)
br label %84
84: ; preds = %49, %55, %66, %76, %74, %77, %46
%85 = phi float [ %72, %76 ], [ %72, %74 ], [ %47, %66 ], [ %83, %77 ], [ %47, %55 ], [ %47, %49 ], [ %47, %46 ]
%86 = add nsw i32 %5, 1
%87 = icmp slt i32 %86, %3
br i1 %87, label %88, label %123
88: ; preds = %84
%89 = add nsw i32 %8, 1
%90 = sext i32 %89 to i64
%91 = getelementptr inbounds i16, i16* %6, i64 %90
%92 = load i16, i16* %91
%93 = icmp sgt i16 %92, 0
br i1 %93, label %94, label %123
94: ; preds = %88
%95 = sext i32 %8 to i64
%96 = getelementptr inbounds i8, i8* %7, i64 %95
%97 = load i8, i8* %96
%98 = getelementptr inbounds i8, i8* %7, i64 %90
%99 = load i8, i8* %98
%100 = icmp eq i8 %97, %99
br i1 %100, label %101, label %123
101: ; preds = %94
%102 = getelementptr inbounds i16, i16* %0, i64 %95
%103 = load i16, i16* %102
%104 = icmp sgt i16 %103, 0
br i1 %104, label %105, label %116
105: ; preds = %101
%106 = getelementptr inbounds float, float* %1, i64 %95
%107 = load float, float* %106
%108 = getelementptr inbounds float, float* %1, i64 %90
%109 = load float, float* %108
%110 = fsub float %107, %109
%111 = tail call float @llvm.fabs.f32(float %110)
%112 = fcmp uge float %111, %85
%113 = icmp eq i16 %103, %92
%114 = select i1 %112, i1 true, i1 %113
br i1 %114, label %123, label %115
115: ; preds = %105
store i16 %92, i16* %102
br label %123
116: ; preds = %101
store i16 %92, i16* %102
%117 = getelementptr inbounds float, float* %1, i64 %95
%118 = load float, float* %117
%119 = getelementptr inbounds float, float* %1, i64 %90
%120 = load float, float* %119
%121 = fsub float %118, %120
%122 = tail call float @llvm.fabs.f32(float %121)
br label %123
123: ; preds = %88, %94, %105, %115, %116, %84
%124 = phi float [ %85, %115 ], [ %85, %105 ], [ %122, %116 ], [ %85, %94 ], [ %85, %88 ], [ %85, %84 ]
%125 = add nsw i32 %4, 1
%126 = icmp slt i32 %125, %2
br i1 %126, label %127, label %155
127: ; preds = %123
%128 = add nsw i32 %8, %3
%129 = sext i32 %128 to i64
%130 = getelementptr inbounds i16, i16* %6, i64 %129
%131 = load i16, i16* %130
%132 = icmp sgt i16 %131, 0
br i1 %132, label %133, label %155
133: ; preds = %127
%134 = sext i32 %8 to i64
%135 = getelementptr inbounds i8, i8* %7, i64 %134
%136 = load i8, i8* %135
%137 = getelementptr inbounds i8, i8* %7, i64 %129
%138 = load i8, i8* %137
%139 = icmp eq i8 %136, %138
br i1 %139, label %140, label %155
140: ; preds = %133
%141 = getelementptr inbounds i16, i16* %0, i64 %134
%142 = load i16, i16* %141
%143 = icmp sgt i16 %142, 0
br i1 %143, label %144, label %154
144: ; preds = %140
%145 = getelementptr inbounds float, float* %1, i64 %134
%146 = load float, float* %145
%147 = getelementptr inbounds float, float* %1, i64 %129
%148 = load float, float* %147
%149 = fsub float %146, %148
%150 = tail call float @llvm.fabs.f32(float %149)
%151 = fcmp uge float %150, %124
%152 = icmp eq i16 %142, %131
%153 = select i1 %151, i1 true, i1 %152
br i1 %153, label %155, label %154
154: ; preds = %140, %144
store i16 %131, i16* %141
br label %155
155: ; preds = %154, %127, %133, %144, %123
ret void
}