#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 bimaru_checkrows(char *labels, char *fields) {
  register size_t x, y;
  register char sum;
  for (y = 0; y < 9; y++) {
    for (x = sum = 0; x < 9; x++)
      sum += fields[y * 9 + x] != 0;
    if (labels[y] - 1 != sum)
      return y;
  }
  return -1;
}


x86 assembly (clang, -O0):
<bimaru_checkrows>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
movq   $0x0,-0x28(%rbp)
cmpq   $0x9,-0x28(%rbp)
jae    11a9 <bimaru_checkrows+0xa9>
movb   $0x0,-0x29(%rbp)
movq   $0x0,-0x20(%rbp)
cmpq   $0x9,-0x20(%rbp)
jae    116c <bimaru_checkrows+0x6c>
mov    -0x18(%rbp),%rax
imul   $0x9,-0x28(%rbp),%rcx
add    -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
setne  %al
and    $0x1,%al
movzbl %al,%ecx
movsbl -0x29(%rbp),%eax
add    %ecx,%eax
mov    %al,-0x29(%rbp)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    112b <bimaru_checkrows+0x2b>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
sub    $0x1,%eax
movsbl -0x29(%rbp),%ecx
cmp    %ecx,%eax
je     1193 <bimaru_checkrows+0x93>
mov    -0x28(%rbp),%rax
mov    %eax,-0x4(%rbp)
jmp    11b0 <bimaru_checkrows+0xb0>
jmp    1198 <bimaru_checkrows+0x98>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    1114 <bimaru_checkrows+0x14>
movl   $0xffffffff,-0x4(%rbp)
mov    -0x4(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<bimaru_checkrows>:
movq   (%rsi),%xmm1
pxor   %xmm0,%xmm0
pcmpeqb %xmm0,%xmm1
pmovmskb %xmm1,%eax
not    %eax
mov    %eax,%ecx
shr    %cl
and    $0x55,%cl
sub    %cl,%al
mov    %eax,%ecx
and    $0x33,%cl
shr    $0x2,%al
and    $0x33,%al
add    %cl,%al
mov    %eax,%ecx
shr    $0x4,%cl
add    %al,%cl
and    $0xf,%cl
movzbl %cl,%ecx
cmpb   $0x1,0x8(%rsi)
sbb    $0xffffffff,%ecx
movsbl (%rdi),%edx
add    $0xffffffff,%edx
xor    %eax,%eax
cmp    %ecx,%edx
jne    13b7 <bimaru_checkrows+0x2b7>
movq   0x9(%rsi),%xmm1
pcmpeqb %xmm0,%xmm1
pmovmskb %xmm1,%eax
not    %eax
mov    %eax,%ecx
shr    %cl
and    $0x55,%cl
sub    %cl,%al
mov    %eax,%ecx
and    $0x33,%cl
shr    $0x2,%al
and    $0x33,%al
add    %cl,%al
mov    %eax,%ecx
shr    $0x4,%cl
add    %al,%cl
and    $0xf,%cl
movzbl %cl,%ecx
cmpb   $0x1,0x11(%rsi)
sbb    $0xffffffff,%ecx
movsbl 0x1(%rdi),%edx
add    $0xffffffff,%edx
mov    $0x1,%eax
cmp    %ecx,%edx
jne    13b7 <bimaru_checkrows+0x2b7>
movq   0x12(%rsi),%xmm1
pxor   %xmm0,%xmm0
pcmpeqb %xmm0,%xmm1
pmovmskb %xmm1,%eax
not    %eax
mov    %eax,%ecx
shr    %cl
and    $0x55,%cl
sub    %cl,%al
mov    %eax,%ecx
and    $0x33,%cl
shr    $0x2,%al
and    $0x33,%al
add    %cl,%al
mov    %eax,%ecx
shr    $0x4,%cl
add    %al,%cl
and    $0xf,%cl
movzbl %cl,%ecx
cmpb   $0x1,0x1a(%rsi)
sbb    $0xffffffff,%ecx
movsbl 0x2(%rdi),%edx
add    $0xffffffff,%edx
mov    $0x2,%eax
cmp    %ecx,%edx
jne    13b7 <bimaru_checkrows+0x2b7>
movq   0x1b(%rsi),%xmm1
pcmpeqb %xmm0,%xmm1
pmovmskb %xmm1,%eax
not    %eax
mov    %eax,%ecx
shr    %cl
and    $0x55,%cl
sub    %cl,%al
mov    %eax,%ecx
and    $0x33,%cl
shr    $0x2,%al
and    $0x33,%al
add    %cl,%al
mov    %eax,%ecx
shr    $0x4,%cl
add    %al,%cl
and    $0xf,%cl
movzbl %cl,%ecx
cmpb   $0x1,0x23(%rsi)
sbb    $0xffffffff,%ecx
movsbl 0x3(%rdi),%edx
add    $0xffffffff,%edx
mov    $0x3,%eax
cmp    %ecx,%edx
jne    13b7 <bimaru_checkrows+0x2b7>
movq   0x24(%rsi),%xmm1
pxor   %xmm0,%xmm0
pcmpeqb %xmm0,%xmm1
pmovmskb %xmm1,%eax
not    %eax
mov    %eax,%ecx
shr    %cl
and    $0x55,%cl
sub    %cl,%al
mov    %eax,%ecx
and    $0x33,%cl
shr    $0x2,%al
and    $0x33,%al
add    %cl,%al
mov    %eax,%ecx
shr    $0x4,%cl
add    %al,%cl
and    $0xf,%cl
movzbl %cl,%ecx
cmpb   $0x1,0x2c(%rsi)
sbb    $0xffffffff,%ecx
movsbl 0x4(%rdi),%edx
add    $0xffffffff,%edx
mov    $0x4,%eax
cmp    %ecx,%edx
jne    13b7 <bimaru_checkrows+0x2b7>
movq   0x2d(%rsi),%xmm1
pcmpeqb %xmm0,%xmm1
pmovmskb %xmm1,%eax
not    %eax
mov    %eax,%ecx
shr    %cl
and    $0x55,%cl
sub    %cl,%al
mov    %eax,%ecx
and    $0x33,%cl
shr    $0x2,%al
and    $0x33,%al
add    %cl,%al
mov    %eax,%ecx
shr    $0x4,%cl
add    %al,%cl
and    $0xf,%cl
movzbl %cl,%ecx
cmpb   $0x1,0x35(%rsi)
sbb    $0xffffffff,%ecx
movsbl 0x5(%rdi),%edx
add    $0xffffffff,%edx
mov    $0x5,%eax
cmp    %ecx,%edx
jne    13b7 <bimaru_checkrows+0x2b7>
movq   0x36(%rsi),%xmm1
pxor   %xmm0,%xmm0
pcmpeqb %xmm0,%xmm1
pmovmskb %xmm1,%eax
not    %eax
mov    %eax,%ecx
shr    %cl
and    $0x55,%cl
sub    %cl,%al
mov    %eax,%ecx
and    $0x33,%cl
shr    $0x2,%al
and    $0x33,%al
add    %cl,%al
mov    %eax,%ecx
shr    $0x4,%cl
add    %al,%cl
and    $0xf,%cl
movzbl %cl,%ecx
cmpb   $0x1,0x3e(%rsi)
sbb    $0xffffffff,%ecx
movsbl 0x6(%rdi),%edx
add    $0xffffffff,%edx
mov    $0x6,%eax
cmp    %ecx,%edx
jne    13b7 <bimaru_checkrows+0x2b7>
movq   0x3f(%rsi),%xmm1
pcmpeqb %xmm0,%xmm1
pmovmskb %xmm1,%eax
not    %eax
mov    %eax,%ecx
shr    %cl
and    $0x55,%cl
sub    %cl,%al
mov    %eax,%ecx
and    $0x33,%cl
shr    $0x2,%al
and    $0x33,%al
add    %cl,%al
mov    %eax,%ecx
shr    $0x4,%cl
add    %al,%cl
and    $0xf,%cl
movzbl %cl,%ecx
cmpb   $0x1,0x47(%rsi)
sbb    $0xffffffff,%ecx
movsbl 0x7(%rdi),%edx
add    $0xffffffff,%edx
mov    $0x7,%eax
cmp    %ecx,%edx
jne    13b7 <bimaru_checkrows+0x2b7>
movq   0x48(%rsi),%xmm0
pxor   %xmm1,%xmm1
pcmpeqb %xmm0,%xmm1
pmovmskb %xmm1,%eax
not    %eax
mov    %eax,%ecx
shr    %cl
and    $0x55,%cl
sub    %cl,%al
mov    %eax,%ecx
and    $0x33,%cl
shr    $0x2,%al
and    $0x33,%al
add    %cl,%al
mov    %eax,%ecx
shr    $0x4,%cl
add    %al,%cl
and    $0xf,%cl
movzbl %cl,%eax
cmpb   $0x1,0x50(%rsi)
sbb    $0xffffffff,%eax
movsbl 0x8(%rdi),%ecx
add    $0xffffffff,%ecx
xor    %edx,%edx
cmp    %eax,%ecx
setne  %dl
lea    (%rdx,%rdx,8),%eax
add    $0xffffffff,%eax
ret

LLVM IR (-O0):
define i32 @bimaru_checkrows(i8* %0, i8* %1) {
%3 = alloca i32
%4 = alloca i8*
%5 = alloca i8*
%6 = alloca i64
%7 = alloca i64
%8 = alloca i8
store i8* %0, i8** %4
store i8* %1, i8** %5
store i64 0, i64* %7
br label %9
9: ; preds = %48, %2
%10 = load i64, i64* %7
%11 = icmp ult i64 %10, 9
br i1 %11, label %12, label %51
12: ; preds = %9
store i8 0, i8* %8
store i64 0, i64* %6
br label %13
13: ; preds = %31, %12
%14 = load i64, i64* %6
%15 = icmp ult i64 %14, 9
br i1 %15, label %16, label %34
16: ; preds = %13
%17 = load i8*, i8** %5
%18 = load i64, i64* %7
%19 = mul i64 %18, 9
%20 = load i64, i64* %6
%21 = add i64 %19, %20
%22 = getelementptr inbounds i8, i8* %17, i64 %21
%23 = load i8, i8* %22
%24 = sext i8 %23 to i32
%25 = icmp ne i32 %24, 0
%26 = zext i1 %25 to i32
%27 = load i8, i8* %8
%28 = sext i8 %27 to i32
%29 = add nsw i32 %28, %26
%30 = trunc i32 %29 to i8
store i8 %30, i8* %8
br label %31
31: ; preds = %16
%32 = load i64, i64* %6
%33 = add i64 %32, 1
store i64 %33, i64* %6
br label %13
34: ; preds = %13
%35 = load i8*, i8** %4
%36 = load i64, i64* %7
%37 = getelementptr inbounds i8, i8* %35, i64 %36
%38 = load i8, i8* %37
%39 = sext i8 %38 to i32
%40 = sub nsw i32 %39, 1
%41 = load i8, i8* %8
%42 = sext i8 %41 to i32
%43 = icmp ne i32 %40, %42
br i1 %43, label %44, label %47
44: ; preds = %34
%45 = load i64, i64* %7
%46 = trunc i64 %45 to i32
store i32 %46, i32* %3
br label %52
47: ; preds = %34
br label %48
48: ; preds = %47
%49 = load i64, i64* %7
%50 = add i64 %49, 1
store i64 %50, i64* %7
br label %9
51: ; preds = %9
store i32 -1, i32* %3
br label %52
52: ; preds = %51, %44
%53 = load i32, i32* %3
ret i32 %53
}

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