int getCantidadConflictosEnReglaVertical(int tabla[9][9], int ii, int jj,
                                         int candidato, int enGral) {
  int i, count = 0;
  for (i = 0; i < 9; i++) {
    if (enGral && i == ii) {
      continue;
    }
    if (tabla[i][jj] == candidato) {
      count++;
    }
  }
  return count;
}


x86 assembly (clang, -O0):
<getCantidadConflictosEnReglaVertical>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8d,-0x18(%rbp)
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x1c(%rbp)
cmpl   $0x9,-0x1c(%rbp)
jge    1183 <getCantidadConflictosEnReglaVertical+0x83>
cmpl   $0x0,-0x18(%rbp)
je     1148 <getCantidadConflictosEnReglaVertical+0x48>
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jne    1148 <getCantidadConflictosEnReglaVertical+0x48>
jmp    1175 <getCantidadConflictosEnReglaVertical+0x75>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
imul   $0x24,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x14(%rbp),%eax
jne    1170 <getCantidadConflictosEnReglaVertical+0x70>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1175 <getCantidadConflictosEnReglaVertical+0x75>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1123 <getCantidadConflictosEnReglaVertical+0x23>
mov    -0x20(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<getCantidadConflictosEnReglaVertical>:
movslq %edx,%rdx
test   %r8d,%r8d
je     1117 <getCantidadConflictosEnReglaVertical+0x17>
test   %esi,%esi
jne    1117 <getCantidadConflictosEnReglaVertical+0x17>
xor    %eax,%eax
cmp    %ecx,0x24(%rdi,%rdx,4)
sete   %al
jmp    1129 <getCantidadConflictosEnReglaVertical+0x29>
xor    %eax,%eax
cmp    %ecx,(%rdi,%rdx,4)
sete   %al
test   %r8d,%r8d
je     118d <getCantidadConflictosEnReglaVertical+0x8d>
cmp    $0x1,%esi
jne    118d <getCantidadConflictosEnReglaVertical+0x8d>
xor    %esi,%esi
cmp    %ecx,0x48(%rdi,%rdx,4)
sete   %sil
add    %esi,%eax
xor    %esi,%esi
cmp    %ecx,0x6c(%rdi,%rdx,4)
sete   %sil
add    %esi,%eax
xor    %esi,%esi
cmp    %ecx,0x90(%rdi,%rdx,4)
sete   %sil
add    %esi,%eax
xor    %esi,%esi
cmp    %ecx,0xb4(%rdi,%rdx,4)
sete   %sil
add    %esi,%eax
xor    %esi,%esi
cmp    %ecx,0xd8(%rdi,%rdx,4)
sete   %sil
add    %esi,%eax
xor    %esi,%esi
cmp    %ecx,0xfc(%rdi,%rdx,4)
sete   %sil
add    %esi,%eax
xor    %esi,%esi
cmp    %ecx,0x120(%rdi,%rdx,4)
sete   %sil
add    %esi,%eax
ret
xor    %r9d,%r9d
cmp    %ecx,0x24(%rdi,%rdx,4)
sete   %r9b
add    %r9d,%eax
test   %r8d,%r8d
je     11a5 <getCantidadConflictosEnReglaVertical+0xa5>
cmp    $0x2,%esi
je     1135 <getCantidadConflictosEnReglaVertical+0x35>
xor    %r9d,%r9d
cmp    %ecx,0x48(%rdi,%rdx,4)
sete   %r9b
add    %r9d,%eax
test   %r8d,%r8d
je     11bd <getCantidadConflictosEnReglaVertical+0xbd>
cmp    $0x3,%esi
je     1141 <getCantidadConflictosEnReglaVertical+0x41>
xor    %r9d,%r9d
cmp    %ecx,0x6c(%rdi,%rdx,4)
sete   %r9b
add    %r9d,%eax
test   %r8d,%r8d
je     11d9 <getCantidadConflictosEnReglaVertical+0xd9>
cmp    $0x4,%esi
je     1150 <getCantidadConflictosEnReglaVertical+0x50>
xor    %r9d,%r9d
cmp    %ecx,0x90(%rdi,%rdx,4)
sete   %r9b
add    %r9d,%eax
test   %r8d,%r8d
je     11f8 <getCantidadConflictosEnReglaVertical+0xf8>
cmp    $0x5,%esi
je     115f <getCantidadConflictosEnReglaVertical+0x5f>
xor    %r9d,%r9d
cmp    %ecx,0xb4(%rdi,%rdx,4)
sete   %r9b
add    %r9d,%eax
test   %r8d,%r8d
je     1217 <getCantidadConflictosEnReglaVertical+0x117>
cmp    $0x6,%esi
je     116e <getCantidadConflictosEnReglaVertical+0x6e>
xor    %r9d,%r9d
cmp    %ecx,0xd8(%rdi,%rdx,4)
sete   %r9b
add    %r9d,%eax
test   %r8d,%r8d
je     1236 <getCantidadConflictosEnReglaVertical+0x136>
cmp    $0x7,%esi
je     117d <getCantidadConflictosEnReglaVertical+0x7d>
xor    %r9d,%r9d
cmp    %ecx,0xfc(%rdi,%rdx,4)
sete   %r9b
add    %r9d,%eax
test   %r8d,%r8d
je     117d <getCantidadConflictosEnReglaVertical+0x7d>
cmp    $0x8,%esi
je     118c <getCantidadConflictosEnReglaVertical+0x8c>
jmp    117d <getCantidadConflictosEnReglaVertical+0x7d>

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

LLVM IR (-O2):
define i32 @getCantidadConflictosEnReglaVertical([9 x i32]* nocapture %0, i32 %1, i32 %2, i32 %3, i32 %4) {
%6 = icmp ne i32 %4, 0
%7 = sext i32 %2 to i64
%8 = icmp eq i32 %1, 0
%9 = and i1 %6, %8
br i1 %9, label %10, label %15
10: ; preds = %5
%11 = getelementptr inbounds [9 x i32], [9 x i32]* %0, i64 1, i64 %7
%12 = load i32, i32* %11
%13 = icmp eq i32 %12, %3
%14 = zext i1 %13 to i32
br label %30
15: ; preds = %5
%16 = getelementptr inbounds [9 x i32], [9 x i32]* %0, i64 0, i64 %7
%17 = load i32, i32* %16
%18 = icmp eq i32 %17, %3
%19 = zext i1 %18 to i32
%20 = icmp eq i32 %1, 1
%21 = and i1 %6, %20
br i1 %21, label %30, label %22
22: ; preds = %15
%23 = getelementptr inbounds [9 x i32], [9 x i32]* %0, i64 1, i64 %7
%24 = load i32, i32* %23
%25 = icmp eq i32 %24, %3
%26 = zext i1 %25 to i32
%27 = add nuw nsw i32 %19, %26
%28 = icmp eq i32 %1, 2
%29 = and i1 %6, %28
br i1 %29, label %45, label %37
30: ; preds = %10, %15
%31 = phi i32 [ %14, %10 ], [ %19, %15 ]
%32 = getelementptr inbounds [9 x i32], [9 x i32]* %0, i64 2, i64 %7
%33 = load i32, i32* %32
%34 = icmp eq i32 %33, %3
%35 = zext i1 %34 to i32
%36 = add nuw nsw i32 %31, %35
br label %45
37: ; preds = %22
%38 = getelementptr inbounds [9 x i32], [9 x i32]* %0, i64 2, i64 %7
%39 = load i32, i32* %38
%40 = icmp eq i32 %39, %3
%41 = zext i1 %40 to i32
%42 = add nuw nsw i32 %27, %41
%43 = icmp eq i32 %1, 3
%44 = and i1 %6, %43
br i1 %44, label %60, label %52
45: ; preds = %30, %22
%46 = phi i32 [ %36, %30 ], [ %27, %22 ]
%47 = getelementptr inbounds [9 x i32], [9 x i32]* %0, i64 3, i64 %7
%48 = load i32, i32* %47
%49 = icmp eq i32 %48, %3
%50 = zext i1 %49 to i32
%51 = add nuw nsw i32 %46, %50
br label %60
52: ; preds = %37
%53 = getelementptr inbounds [9 x i32], [9 x i32]* %0, i64 3, i64 %7
%54 = load i32, i32* %53
%55 = icmp eq i32 %54, %3
%56 = zext i1 %55 to i32
%57 = add nuw nsw i32 %42, %56
%58 = icmp eq i32 %1, 4
%59 = and i1 %6, %58
br i1 %59, label %75, label %67
60: ; preds = %45, %37
%61 = phi i32 [ %51, %45 ], [ %42, %37 ]
%62 = getelementptr inbounds [9 x i32], [9 x i32]* %0, i64 4, i64 %7
%63 = load i32, i32* %62
%64 = icmp eq i32 %63, %3
%65 = zext i1 %64 to i32
%66 = add nuw nsw i32 %61, %65
br label %75
67: ; preds = %52
%68 = getelementptr inbounds [9 x i32], [9 x i32]* %0, i64 4, i64 %7
%69 = load i32, i32* %68
%70 = icmp eq i32 %69, %3
%71 = zext i1 %70 to i32
%72 = add nuw nsw i32 %57, %71
%73 = icmp eq i32 %1, 5
%74 = and i1 %6, %73
br i1 %74, label %90, label %82
75: ; preds = %60, %52
%76 = phi i32 [ %66, %60 ], [ %57, %52 ]
%77 = getelementptr inbounds [9 x i32], [9 x i32]* %0, i64 5, i64 %7
%78 = load i32, i32* %77
%79 = icmp eq i32 %78, %3
%80 = zext i1 %79 to i32
%81 = add nuw nsw i32 %76, %80
br label %90
82: ; preds = %67
%83 = getelementptr inbounds [9 x i32], [9 x i32]* %0, i64 5, i64 %7
%84 = load i32, i32* %83
%85 = icmp eq i32 %84, %3
%86 = zext i1 %85 to i32
%87 = add nuw nsw i32 %72, %86
%88 = icmp eq i32 %1, 6
%89 = and i1 %6, %88
br i1 %89, label %105, label %97
90: ; preds = %75, %67
%91 = phi i32 [ %81, %75 ], [ %72, %67 ]
%92 = getelementptr inbounds [9 x i32], [9 x i32]* %0, i64 6, i64 %7
%93 = load i32, i32* %92
%94 = icmp eq i32 %93, %3
%95 = zext i1 %94 to i32
%96 = add nuw nsw i32 %91, %95
br label %105
97: ; preds = %82
%98 = getelementptr inbounds [9 x i32], [9 x i32]* %0, i64 6, i64 %7
%99 = load i32, i32* %98
%100 = icmp eq i32 %99, %3
%101 = zext i1 %100 to i32
%102 = add nuw nsw i32 %87, %101
%103 = icmp eq i32 %1, 7
%104 = and i1 %6, %103
br i1 %104, label %120, label %112
105: ; preds = %90, %82
%106 = phi i32 [ %96, %90 ], [ %87, %82 ]
%107 = getelementptr inbounds [9 x i32], [9 x i32]* %0, i64 7, i64 %7
%108 = load i32, i32* %107
%109 = icmp eq i32 %108, %3
%110 = zext i1 %109 to i32
%111 = add nuw nsw i32 %106, %110
br label %120
112: ; preds = %97
%113 = getelementptr inbounds [9 x i32], [9 x i32]* %0, i64 7, i64 %7
%114 = load i32, i32* %113
%115 = icmp eq i32 %114, %3
%116 = zext i1 %115 to i32
%117 = add nuw nsw i32 %102, %116
%118 = icmp eq i32 %1, 8
%119 = and i1 %6, %118
br i1 %119, label %127, label %120
120: ; preds = %97, %105, %112
%121 = phi i32 [ %117, %112 ], [ %111, %105 ], [ %102, %97 ]
%122 = getelementptr inbounds [9 x i32], [9 x i32]* %0, i64 8, i64 %7
%123 = load i32, i32* %122
%124 = icmp eq i32 %123, %3
%125 = zext i1 %124 to i32
%126 = add nuw nsw i32 %121, %125
br label %127
127: ; preds = %120, %112
%128 = phi i32 [ %117, %112 ], [ %126, %120 ]
ret i32 %128
}