int is_neigh(unsigned int *J_slap, unsigned int *r_slap, unsigned int N,
             unsigned int i, unsigned int j) {
  unsigned int l;
  unsigned int count;
  count = 0;
  for (l = r_slap[i]; l < r_slap[i + 1]; l++) {
    if (J_slap[l] == j)
      count++;
  }
  return count;
}


x86 assembly (clang, -O0):
<is_neigh>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x10(%rbp),%rcx
mov    -0x18(%rbp),%edx
add    $0x1,%edx
mov    %edx,%edx
cmp    (%rcx,%rdx,4),%eax
jae    1171 <is_neigh+0x71>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    (%rax,%rcx,4),%eax
cmp    -0x1c(%rbp),%eax
jne    115e <is_neigh+0x5e>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1163 <is_neigh+0x63>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    112a <is_neigh+0x2a>
mov    -0x24(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<is_neigh>:
push   %rbx
mov    %ecx,%eax
mov    (%rsi,%rax,4),%edx
add    $0x1,%ecx
mov    (%rsi,%rcx,4),%ecx
xor    %eax,%eax
cmp    %ecx,%edx
jae    1215 <is_neigh+0x115>
mov    %rcx,%r11
sub    %rdx,%r11
xor    %eax,%eax
cmp    $0x8,%r11
jb     1200 <is_neigh+0x100>
mov    %r11,%r9
and    $0xfffffffffffffff8,%r9
movd   %r8d,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x8(%r9),%rax
mov    %rax,%r10
shr    $0x3,%r10
add    $0x1,%r10
test   %rax,%rax
je     1217 <is_neigh+0x117>
mov    %r10,%rsi
and    $0xfffffffffffffffe,%rsi
lea    (%rdi,%rdx,4),%rbx
add    $0x30,%rbx
pxor   %xmm1,%xmm1
xor    %eax,%eax
pxor   %xmm2,%xmm2
nopw   0x0(%rax,%rax,1)
movdqu -0x30(%rbx,%rax,4),%xmm3
movdqu -0x20(%rbx,%rax,4),%xmm4
movdqu -0x10(%rbx,%rax,4),%xmm5
movdqu (%rbx,%rax,4),%xmm6
pcmpeqd %xmm0,%xmm3
psubd  %xmm3,%xmm1
pcmpeqd %xmm0,%xmm4
psubd  %xmm4,%xmm2
pcmpeqd %xmm0,%xmm5
psubd  %xmm5,%xmm1
pcmpeqd %xmm0,%xmm6
psubd  %xmm6,%xmm2
add    $0x10,%rax
add    $0xfffffffffffffffe,%rsi
jne    1170 <is_neigh+0x70>
test   $0x1,%r10b
je     11d5 <is_neigh+0xd5>
add    %rdx,%rax
movdqu (%rdi,%rax,4),%xmm3
movdqu 0x10(%rdi,%rax,4),%xmm4
pcmpeqd %xmm0,%xmm3
psubd  %xmm3,%xmm1
pcmpeqd %xmm0,%xmm4
psubd  %xmm4,%xmm2
paddd  %xmm2,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%eax
cmp    %r9,%r11
je     1215 <is_neigh+0x115>
add    %r9,%rdx
nopw   0x0(%rax,%rax,1)
xor    %esi,%esi
cmp    %r8d,(%rdi,%rdx,4)
sete   %sil
add    %esi,%eax
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    1200 <is_neigh+0x100>
pop    %rbx
ret
pxor   %xmm1,%xmm1
xor    %eax,%eax
pxor   %xmm2,%xmm2
test   $0x1,%r10b
jne    11b7 <is_neigh+0xb7>
jmp    11d5 <is_neigh+0xd5>

LLVM IR (-O0):
define i32 @is_neigh(i32* %0, i32* %1, i32 %2, i32 %3, i32 %4) {
%6 = alloca i32*
%7 = alloca i32*
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
store i32* %0, i32** %6
store i32* %1, i32** %7
store i32 %2, i32* %8
store i32 %3, i32* %9
store i32 %4, i32* %10
store i32 0, i32* %12
%13 = load i32*, i32** %7
%14 = load i32, i32* %9
%15 = zext i32 %14 to i64
%16 = getelementptr inbounds i32, i32* %13, i64 %15
%17 = load i32, i32* %16
store i32 %17, i32* %11
br label %18
18: ; preds = %39, %5
%19 = load i32, i32* %11
%20 = load i32*, i32** %7
%21 = load i32, i32* %9
%22 = add i32 %21, 1
%23 = zext i32 %22 to i64
%24 = getelementptr inbounds i32, i32* %20, i64 %23
%25 = load i32, i32* %24
%26 = icmp ult i32 %19, %25
br i1 %26, label %27, label %42
27: ; preds = %18
%28 = load i32*, i32** %6
%29 = load i32, i32* %11
%30 = zext i32 %29 to i64
%31 = getelementptr inbounds i32, i32* %28, i64 %30
%32 = load i32, i32* %31
%33 = load i32, i32* %10
%34 = icmp eq i32 %32, %33
br i1 %34, label %35, label %38
35: ; preds = %27
%36 = load i32, i32* %12
%37 = add i32 %36, 1
store i32 %37, i32* %12
br label %38
38: ; preds = %35, %27
br label %39
39: ; preds = %38
%40 = load i32, i32* %11
%41 = add i32 %40, 1
store i32 %41, i32* %11
br label %18
42: ; preds = %18
%43 = load i32, i32* %12
ret i32 %43
}

LLVM IR (-O2):
define i32 @is_neigh(i32* nocapture %0, i32* nocapture %1, i32 %2, i32 %3, i32 %4) {
%6 = zext i32 %3 to i64
%7 = getelementptr inbounds i32, i32* %1, i64 %6
%8 = load i32, i32* %7
%9 = add i32 %3, 1
%10 = zext i32 %9 to i64
%11 = getelementptr inbounds i32, i32* %1, i64 %10
%12 = load i32, i32* %11
%13 = icmp ult i32 %8, %12
br i1 %13, label %14, label %108
14: ; preds = %5
%15 = zext i32 %8 to i64
%16 = zext i32 %12 to i64
%17 = sub nsw i64 %16, %15
%18 = icmp ult i64 %17, 8
br i1 %18, label %95, label %19
19: ; preds = %14
%20 = and i64 %17, -8
%21 = add nsw i64 %20, %15
%22 = insertelement <4 x i32> poison, i32 %4, i64 0
%23 = shufflevector <4 x i32> %22, <4 x i32> poison, <4 x i32> zeroinitializer
%24 = insertelement <4 x i32> poison, i32 %4, i64 0
%25 = shufflevector <4 x i32> %24, <4 x i32> poison, <4 x i32> zeroinitializer
%26 = add nsw i64 %20, -8
%27 = lshr exact i64 %26, 3
%28 = add nuw nsw i64 %27, 1
%29 = and i64 %28, 1
%30 = icmp eq i64 %26, 0
br i1 %30, label %68, label %31
31: ; preds = %19
%32 = and i64 %28, 4611686018427387902
br label %33
33: ; preds = %33, %31
%34 = phi i64 [ 0, %31 ], [ %65, %33 ]
%35 = phi <4 x i32> [ zeroinitializer, %31 ], [ %63, %33 ]
%36 = phi <4 x i32> [ zeroinitializer, %31 ], [ %64, %33 ]
%37 = phi i64 [ 0, %31 ], [ %66, %33 ]
%38 = add i64 %34, %15
%39 = getelementptr inbounds i32, i32* %0, i64 %38
%40 = bitcast i32* %39 to <4 x i32>*
%41 = load <4 x i32>, <4 x i32>* %40
%42 = getelementptr inbounds i32, i32* %39, i64 4
%43 = bitcast i32* %42 to <4 x i32>*
%44 = load <4 x i32>, <4 x i32>* %43
%45 = icmp eq <4 x i32> %41, %23
%46 = icmp eq <4 x i32> %44, %25
%47 = zext <4 x i1> %45 to <4 x i32>
%48 = zext <4 x i1> %46 to <4 x i32>
%49 = add <4 x i32> %35, %47
%50 = add <4 x i32> %36, %48
%51 = or i64 %34, 8
%52 = add i64 %51, %15
%53 = getelementptr inbounds i32, i32* %0, i64 %52
%54 = bitcast i32* %53 to <4 x i32>*
%55 = load <4 x i32>, <4 x i32>* %54
%56 = getelementptr inbounds i32, i32* %53, i64 4
%57 = bitcast i32* %56 to <4 x i32>*
%58 = load <4 x i32>, <4 x i32>* %57
%59 = icmp eq <4 x i32> %55, %23
%60 = icmp eq <4 x i32> %58, %25
%61 = zext <4 x i1> %59 to <4 x i32>
%62 = zext <4 x i1> %60 to <4 x i32>
%63 = add <4 x i32> %49, %61
%64 = add <4 x i32> %50, %62
%65 = add nuw i64 %34, 16
%66 = add i64 %37, 2
%67 = icmp eq i64 %66, %32
br i1 %67, label %68, label %33
68: ; preds = %33, %19
%69 = phi <4 x i32> [ undef, %19 ], [ %63, %33 ]
%70 = phi <4 x i32> [ undef, %19 ], [ %64, %33 ]
%71 = phi i64 [ 0, %19 ], [ %65, %33 ]
%72 = phi <4 x i32> [ zeroinitializer, %19 ], [ %63, %33 ]
%73 = phi <4 x i32> [ zeroinitializer, %19 ], [ %64, %33 ]
%74 = icmp eq i64 %29, 0
br i1 %74, label %89, label %75
75: ; preds = %68
%76 = add i64 %71, %15
%77 = getelementptr inbounds i32, i32* %0, i64 %76
%78 = bitcast i32* %77 to <4 x i32>*
%79 = load <4 x i32>, <4 x i32>* %78
%80 = getelementptr inbounds i32, i32* %77, i64 4
%81 = bitcast i32* %80 to <4 x i32>*
%82 = load <4 x i32>, <4 x i32>* %81
%83 = icmp eq <4 x i32> %79, %23
%84 = icmp eq <4 x i32> %82, %25
%85 = zext <4 x i1> %83 to <4 x i32>
%86 = zext <4 x i1> %84 to <4 x i32>
%87 = add <4 x i32> %72, %85
%88 = add <4 x i32> %73, %86
br label %89
89: ; preds = %68, %75
%90 = phi <4 x i32> [ %69, %68 ], [ %87, %75 ]
%91 = phi <4 x i32> [ %70, %68 ], [ %88, %75 ]
%92 = add <4 x i32> %91, %90
%93 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %92)
%94 = icmp eq i64 %17, %20
br i1 %94, label %108, label %95
95: ; preds = %14, %89
%96 = phi i64 [ %15, %14 ], [ %21, %89 ]
%97 = phi i32 [ 0, %14 ], [ %93, %89 ]
br label %98
98: ; preds = %95, %98
%99 = phi i64 [ %106, %98 ], [ %96, %95 ]
%100 = phi i32 [ %105, %98 ], [ %97, %95 ]
%101 = getelementptr inbounds i32, i32* %0, i64 %99
%102 = load i32, i32* %101
%103 = icmp eq i32 %102, %4
%104 = zext i1 %103 to i32
%105 = add i32 %100, %104
%106 = add nuw nsw i64 %99, 1
%107 = icmp eq i64 %106, %16
br i1 %107, label %108, label %98
108: ; preds = %98, %89, %5
%109 = phi i32 [ 0, %5 ], [ %93, %89 ], [ %105, %98 ]
ret i32 %109
}