#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 */
typedef unsigned int x;

/* Variables and functions */
int /*<<< orphan*/ scanf(char *, char *);
char *strchr(char *, char);
unsigned count_black(unsigned w, unsigned h) {
  char tiles[20][20 + 1] = {0};
  unsigned q[20 * 20] = {0};
  unsigned head = 0;
  unsigned count = 0;
  unsigned x = 0;
  unsigned y = 0;
  const char *vp = NULL;
  for (unsigned i = 0; i < h; ++i) {
    scanf("%s", tiles[i]);
    vp = strchr(tiles[i], '@');
    if (NULL != vp) {
      q[count++] = ((vp - tiles[i]) + ((i) << 16));
      tiles[i][vp - tiles[i]] = '@';
    };
  }
  while (head != count) {
    x = ((q[head]) % (1 << 16));
    y = ((q[head]) >> 16);
    head++;
    if (x + 1 < w && '.' == tiles[y][x + 1]) {
      q[count++] = ((x + 1) + ((y) << 16));
      tiles[y][x + 1] = '@';
    };
    if (y > 0 && '.' == tiles[y - 1][x]) {
      q[count++] = ((x) + ((y - 1) << 16));
      tiles[y - 1][x] = '@';
    };
    if (x > 0 && '.' == tiles[y][x - 1]) {
      q[count++] = ((x - 1) + ((y) << 16));
      tiles[y][x - 1] = '@';
    };
    if (y + 1 < h && '.' == tiles[y + 1][x]) {
      q[count++] = ((x) + ((y + 1) << 16));
      tiles[y + 1][x] = '@';
    };
  }
  return count;
}


x86 assembly (clang, -O0):
<count_black>:
push   %rbp
mov    %rsp,%rbp
sub    $0x810,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
lea    -0x1b0(%rbp),%rdi
xor    %esi,%esi
mov    $0x1a4,%edx
call   1040 <memset@plt>
lea    -0x7f0(%rbp),%rdi
xor    %esi,%esi
mov    $0x640,%edx
call   1040 <memset@plt>
movl   $0x0,-0x7f4(%rbp)
movl   $0x0,-0x7f8(%rbp)
movl   $0x0,-0x7fc(%rbp)
movl   $0x0,-0x800(%rbp)
movq   $0x0,-0x808(%rbp)
movl   $0x0,-0x80c(%rbp)
mov    -0x80c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jae    12a4 <count_black+0x174>
mov    -0x80c(%rbp),%eax
lea    -0x1b0(%rbp),%rsi
imul   $0x15,%rax,%rax
add    %rax,%rsi
lea    0xe32(%rip),%rdi
call   1050 <scanf@plt>
mov    -0x80c(%rbp),%eax
lea    -0x1b0(%rbp),%rdi
imul   $0x15,%rax,%rax
add    %rax,%rdi
mov    $0x40,%esi
call   1030 <strchr@plt>
mov    %rax,-0x808(%rbp)
xor    %eax,%eax
cmp    -0x808(%rbp),%rax
je     128b <count_black+0x15b>
mov    -0x808(%rbp),%rax
mov    -0x80c(%rbp),%ecx
mov    %ecx,%edx
lea    -0x1b0(%rbp),%rcx
imul   $0x15,%rdx,%rdx
add    %rdx,%rcx
sub    %rcx,%rax
mov    -0x80c(%rbp),%ecx
shl    $0x10,%ecx
mov    %ecx,%ecx
add    %rcx,%rax
mov    %eax,%ecx
mov    -0x7f8(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x7f8(%rbp)
mov    %eax,%eax
mov    %ecx,-0x7f0(%rbp,%rax,4)
mov    -0x80c(%rbp),%eax
mov    %eax,%ecx
lea    -0x1b0(%rbp),%rax
imul   $0x15,%rcx,%rcx
add    %rcx,%rax
mov    -0x808(%rbp),%rcx
mov    -0x80c(%rbp),%edx
mov    %edx,%esi
lea    -0x1b0(%rbp),%rdx
imul   $0x15,%rsi,%rsi
add    %rsi,%rdx
sub    %rdx,%rcx
movb   $0x40,(%rax,%rcx,1)
jmp    1290 <count_black+0x160>
mov    -0x80c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80c(%rbp)
jmp    11a4 <count_black+0x74>
jmp    12a9 <count_black+0x179>
mov    -0x7f4(%rbp),%eax
cmp    -0x7f8(%rbp),%eax
je     154f <count_black+0x41f>
mov    -0x7f4(%rbp),%eax
mov    -0x7f0(%rbp,%rax,4),%eax
and    $0xffff,%eax
mov    %eax,-0x7fc(%rbp)
mov    -0x7f4(%rbp),%eax
mov    -0x7f0(%rbp,%rax,4),%eax
shr    $0x10,%eax
mov    %eax,-0x800(%rbp)
mov    -0x7f4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7f4(%rbp)
mov    -0x7fc(%rbp),%eax
add    $0x1,%eax
cmp    -0x4(%rbp),%eax
jae    138f <count_black+0x25f>
mov    -0x800(%rbp),%eax
mov    %eax,%ecx
lea    -0x1b0(%rbp),%rax
imul   $0x15,%rcx,%rcx
add    %rcx,%rax
mov    -0x7fc(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movsbl (%rax,%rcx,1),%ecx
mov    $0x2e,%eax
cmp    %ecx,%eax
jne    138f <count_black+0x25f>
mov    -0x7fc(%rbp),%ecx
add    $0x1,%ecx
mov    -0x800(%rbp),%eax
shl    $0x10,%eax
add    %eax,%ecx
mov    -0x7f8(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x7f8(%rbp)
mov    %eax,%eax
mov    %ecx,-0x7f0(%rbp,%rax,4)
mov    -0x800(%rbp),%eax
mov    %eax,%ecx
lea    -0x1b0(%rbp),%rax
imul   $0x15,%rcx,%rcx
add    %rcx,%rax
mov    -0x7fc(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movb   $0x40,(%rax,%rcx,1)
cmpl   $0x0,-0x800(%rbp)
jbe    1421 <count_black+0x2f1>
mov    -0x800(%rbp),%eax
sub    $0x1,%eax
mov    %eax,%eax
mov    %eax,%ecx
lea    -0x1b0(%rbp),%rax
imul   $0x15,%rcx,%rcx
add    %rcx,%rax
mov    -0x7fc(%rbp),%ecx
movsbl (%rax,%rcx,1),%ecx
mov    $0x2e,%eax
cmp    %ecx,%eax
jne    1421 <count_black+0x2f1>
mov    -0x7fc(%rbp),%ecx
mov    -0x800(%rbp),%eax
sub    $0x1,%eax
shl    $0x10,%eax
add    %eax,%ecx
mov    -0x7f8(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x7f8(%rbp)
mov    %eax,%eax
mov    %ecx,-0x7f0(%rbp,%rax,4)
mov    -0x800(%rbp),%eax
sub    $0x1,%eax
mov    %eax,%eax
mov    %eax,%ecx
lea    -0x1b0(%rbp),%rax
imul   $0x15,%rcx,%rcx
add    %rcx,%rax
mov    -0x7fc(%rbp),%ecx
movb   $0x40,(%rax,%rcx,1)
cmpl   $0x0,-0x7fc(%rbp)
jbe    14b3 <count_black+0x383>
mov    -0x800(%rbp),%eax
mov    %eax,%ecx
lea    -0x1b0(%rbp),%rax
imul   $0x15,%rcx,%rcx
add    %rcx,%rax
mov    -0x7fc(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
movsbl (%rax,%rcx,1),%ecx
mov    $0x2e,%eax
cmp    %ecx,%eax
jne    14b3 <count_black+0x383>
mov    -0x7fc(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x800(%rbp),%eax
shl    $0x10,%eax
add    %eax,%ecx
mov    -0x7f8(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x7f8(%rbp)
mov    %eax,%eax
mov    %ecx,-0x7f0(%rbp,%rax,4)
mov    -0x800(%rbp),%eax
mov    %eax,%ecx
lea    -0x1b0(%rbp),%rax
imul   $0x15,%rcx,%rcx
add    %rcx,%rax
mov    -0x7fc(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
movb   $0x40,(%rax,%rcx,1)
mov    -0x800(%rbp),%eax
add    $0x1,%eax
cmp    -0x8(%rbp),%eax
jae    154a <count_black+0x41a>
mov    -0x800(%rbp),%eax
add    $0x1,%eax
mov    %eax,%eax
mov    %eax,%ecx
lea    -0x1b0(%rbp),%rax
imul   $0x15,%rcx,%rcx
add    %rcx,%rax
mov    -0x7fc(%rbp),%ecx
movsbl (%rax,%rcx,1),%ecx
mov    $0x2e,%eax
cmp    %ecx,%eax
jne    154a <count_black+0x41a>
mov    -0x7fc(%rbp),%ecx
mov    -0x800(%rbp),%eax
add    $0x1,%eax
shl    $0x10,%eax
add    %eax,%ecx
mov    -0x7f8(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x7f8(%rbp)
mov    %eax,%eax
mov    %ecx,-0x7f0(%rbp,%rax,4)
mov    -0x800(%rbp),%eax
add    $0x1,%eax
mov    %eax,%eax
mov    %eax,%ecx
lea    -0x1b0(%rbp),%rax
imul   $0x15,%rcx,%rcx
add    %rcx,%rax
mov    -0x7fc(%rbp),%ecx
movb   $0x40,(%rax,%rcx,1)
jmp    12a9 <count_black+0x179>
mov    -0x7f8(%rbp),%eax
add    $0x810,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<count_black>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x808,%rsp
mov    %esi,%r15d
mov    %edi,%ebx
lea    0x10(%rsp),%r14
xor    %r12d,%r12d
mov    $0x1a4,%edx
mov    %r14,%rdi
xor    %esi,%esi
call   1040 <memset@plt>
lea    0x1c0(%rsp),%rdi
mov    $0x640,%edx
xor    %esi,%esi
call   1040 <memset@plt>
test   %r15d,%r15d
je     1339 <count_black+0x209>
mov    %ebx,0xc(%rsp)
mov    %r15d,%r15d
mov    %r14d,%ebx
neg    %ebx
mov    %r14,%rbp
neg    %rbp
xor    %r12d,%r12d
xor    %r13d,%r13d
jmp    11b8 <count_black+0x88>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r12
add    $0xffeb,%rbx
add    $0xffffffffffffffeb,%rbp
add    $0x15,%r14
cmp    %r12,%r15
je     1204 <count_black+0xd4>
lea    0xe41(%rip),%rdi
mov    %r14,%rsi
call   1050 <scanf@plt>
mov    %r14,%rdi
mov    $0x40,%esi
call   1030 <strchr@plt>
test   %rax,%rax
je     11a0 <count_black+0x70>
mov    %rax,%rcx
add    %rbp,%rcx
add    %ebx,%eax
mov    %r13d,%edx
add    $0x1,%r13d
mov    %eax,0x1c0(%rsp,%rdx,4)
lea    (%r12,%r12,4),%rax
lea    (%r12,%rax,4),%rax
add    %rsp,%rax
add    $0x10,%rax
movb   $0x40,(%rax,%rcx,1)
jmp    11a0 <count_black+0x70>
xor    %r12d,%r12d
test   %r13d,%r13d
je     1339 <count_black+0x209>
mov    0xc(%rsp),%ebx
jmp    1229 <count_black+0xf9>
cs nopw 0x0(%rax,%rax,1)
cmp    %r13d,%r12d
je     1339 <count_black+0x209>
mov    %r12d,%eax
mov    0x1c0(%rsp,%rax,4),%edx
movzwl %dx,%ecx
mov    %rdx,%rax
shr    $0x10,%rax
lea    0x1(%rcx),%rsi
cmp    %ebx,%esi
jae    1278 <count_black+0x148>
lea    (%rax,%rax,4),%rdi
lea    (%rax,%rdi,4),%rdi
add    %rsp,%rdi
add    $0x10,%rdi
cmpb   $0x2e,(%rsi,%rdi,1)
jne    1278 <count_black+0x148>
add    %rsi,%rdi
mov    %edx,%ebp
and    $0xffff0000,%ebp
add    %esi,%ebp
mov    %r13d,%esi
add    $0x1,%r13d
mov    %ebp,0x1c0(%rsp,%rsi,4)
movb   $0x40,(%rdi)
cmp    $0x10000,%edx
jb     12b4 <count_black+0x184>
lea    -0x1(%rax),%esi
mov    %ecx,%ebp
lea    (%rsi,%rsi,4),%rdi
lea    (%rsi,%rdi,4),%rdi
add    %rsp,%rdi
add    $0x10,%rdi
cmpb   $0x2e,0x0(%rbp,%rdi,1)
jne    12b4 <count_black+0x184>
add    %rbp,%rdi
shl    $0x10,%esi
or     %ecx,%esi
mov    %r13d,%ebp
add    $0x1,%r13d
mov    %esi,0x1c0(%rsp,%rbp,4)
movb   $0x40,(%rdi)
test   %ecx,%ecx
je     12ee <count_black+0x1be>
mov    %eax,%edi
lea    -0x1(%rcx),%esi
lea    (%rdi,%rdi,4),%rbp
lea    (%rdi,%rbp,4),%rdi
add    %rsp,%rdi
add    $0x10,%rdi
cmpb   $0x2e,(%rsi,%rdi,1)
jne    12ee <count_black+0x1be>
add    %rsi,%rdi
and    $0xffff0000,%edx
add    %edx,%esi
mov    %r13d,%edx
add    $0x1,%r13d
mov    %esi,0x1c0(%rsp,%rdx,4)
movb   $0x40,(%rdi)
add    $0x1,%r12d
add    $0x1,%eax
cmp    %r15d,%eax
jae    1220 <count_black+0xf0>
mov    %eax,%edx
mov    %ecx,%esi
lea    (%rdx,%rdx,4),%rdi
lea    (%rdx,%rdi,4),%rdx
add    %rsp,%rdx
add    $0x10,%rdx
cmpb   $0x2e,(%rsi,%rdx,1)
jne    1220 <count_black+0xf0>
add    %rsi,%rdx
shl    $0x10,%eax
or     %ecx,%eax
mov    %r13d,%ecx
add    $0x1,%r13d
mov    %eax,0x1c0(%rsp,%rcx,4)
movb   $0x40,(%rdx)
jmp    1220 <count_black+0xf0>
mov    %r12d,%eax
add    $0x808,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [3 x i8] c"%s\00"
define i32 @count_black(i32 %0, i32 %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca [20 x [21 x i8]]
%6 = alloca [400 x i32]
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i8*
%12 = alloca i32
store i32 %0, i32* %3
store i32 %1, i32* %4
%13 = bitcast [20 x [21 x i8]]* %5 to i8*
%14 = bitcast [400 x i32]* %6 to i8*
store i32 0, i32* %7
store i32 0, i32* %8
store i32 0, i32* %9
store i32 0, i32* %10
store i8* null, i8** %11
store i32 0, i32* %12
br label %15
15: ; preds = %63, %2
%16 = load i32, i32* %12
%17 = load i32, i32* %4
%18 = icmp ult i32 %16, %17
br i1 %18, label %19, label %66
19: ; preds = %15
%20 = load i32, i32* %12
%21 = zext i32 %20 to i64
%22 = getelementptr inbounds [20 x [21 x i8]], [20 x [21 x i8]]* %5, i64 0, i64 %21
%23 = getelementptr inbounds [21 x i8], [21 x i8]* %22, i64 0, i64 0
%24 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i8* %23)
%25 = load i32, i32* %12
%26 = zext i32 %25 to i64
%27 = getelementptr inbounds [20 x [21 x i8]], [20 x [21 x i8]]* %5, i64 0, i64 %26
%28 = getelementptr inbounds [21 x i8], [21 x i8]* %27, i64 0, i64 0
%29 = call i8* @strchr(i8* %28, i8 signext 64)
store i8* %29, i8** %11
%30 = load i8*, i8** %11
%31 = icmp ne i8* null, %30
br i1 %31, label %32, label %62
32: ; preds = %19
%33 = load i8*, i8** %11
%34 = load i32, i32* %12
%35 = zext i32 %34 to i64
%36 = getelementptr inbounds [20 x [21 x i8]], [20 x [21 x i8]]* %5, i64 0, i64 %35
%37 = getelementptr inbounds [21 x i8], [21 x i8]* %36, i64 0, i64 0
%38 = ptrtoint i8* %33 to i64
%39 = ptrtoint i8* %37 to i64
%40 = sub i64 %38, %39
%41 = load i32, i32* %12
%42 = shl i32 %41, 16
%43 = zext i32 %42 to i64
%44 = add nsw i64 %40, %43
%45 = trunc i64 %44 to i32
%46 = load i32, i32* %8
%47 = add i32 %46, 1
store i32 %47, i32* %8
%48 = zext i32 %46 to i64
%49 = getelementptr inbounds [400 x i32], [400 x i32]* %6, i64 0, i64 %48
store i32 %45, i32* %49
%50 = load i32, i32* %12
%51 = zext i32 %50 to i64
%52 = getelementptr inbounds [20 x [21 x i8]], [20 x [21 x i8]]* %5, i64 0, i64 %51
%53 = load i8*, i8** %11
%54 = load i32, i32* %12
%55 = zext i32 %54 to i64
%56 = getelementptr inbounds [20 x [21 x i8]], [20 x [21 x i8]]* %5, i64 0, i64 %55
%57 = getelementptr inbounds [21 x i8], [21 x i8]* %56, i64 0, i64 0
%58 = ptrtoint i8* %53 to i64
%59 = ptrtoint i8* %57 to i64
%60 = sub i64 %58, %59
%61 = getelementptr inbounds [21 x i8], [21 x i8]* %52, i64 0, i64 %60
store i8 64, i8* %61
br label %62
62: ; preds = %32, %19
br label %63
63: ; preds = %62
%64 = load i32, i32* %12
%65 = add i32 %64, 1
store i32 %65, i32* %12
br label %15
66: ; preds = %15
br label %67
67: ; preds = %211, %66
%68 = load i32, i32* %7
%69 = load i32, i32* %8
%70 = icmp ne i32 %68, %69
br i1 %70, label %71, label %212
71: ; preds = %67
%72 = load i32, i32* %7
%73 = zext i32 %72 to i64
%74 = getelementptr inbounds [400 x i32], [400 x i32]* %6, i64 0, i64 %73
%75 = load i32, i32* %74
%76 = urem i32 %75, 65536
store i32 %76, i32* %9
%77 = load i32, i32* %7
%78 = zext i32 %77 to i64
%79 = getelementptr inbounds [400 x i32], [400 x i32]* %6, i64 0, i64 %78
%80 = load i32, i32* %79
%81 = lshr i32 %80, 16
store i32 %81, i32* %10
%82 = load i32, i32* %7
%83 = add i32 %82, 1
store i32 %83, i32* %7
%84 = load i32, i32* %9
%85 = add i32 %84, 1
%86 = load i32, i32* %3
%87 = icmp ult i32 %85, %86
br i1 %87, label %88, label %116
88: ; preds = %71
%89 = load i32, i32* %10
%90 = zext i32 %89 to i64
%91 = getelementptr inbounds [20 x [21 x i8]], [20 x [21 x i8]]* %5, i64 0, i64 %90
%92 = load i32, i32* %9
%93 = add i32 %92, 1
%94 = zext i32 %93 to i64
%95 = getelementptr inbounds [21 x i8], [21 x i8]* %91, i64 0, i64 %94
%96 = load i8, i8* %95
%97 = sext i8 %96 to i32
%98 = icmp eq i32 46, %97
br i1 %98, label %99, label %116
99: ; preds = %88
%100 = load i32, i32* %9
%101 = add i32 %100, 1
%102 = load i32, i32* %10
%103 = shl i32 %102, 16
%104 = add i32 %101, %103
%105 = load i32, i32* %8
%106 = add i32 %105, 1
store i32 %106, i32* %8
%107 = zext i32 %105 to i64
%108 = getelementptr inbounds [400 x i32], [400 x i32]* %6, i64 0, i64 %107
store i32 %104, i32* %108
%109 = load i32, i32* %10
%110 = zext i32 %109 to i64
%111 = getelementptr inbounds [20 x [21 x i8]], [20 x [21 x i8]]* %5, i64 0, i64 %110
%112 = load i32, i32* %9
%113 = add i32 %112, 1
%114 = zext i32 %113 to i64
%115 = getelementptr inbounds [21 x i8], [21 x i8]* %111, i64 0, i64 %114
store i8 64, i8* %115
br label %116
116: ; preds = %99, %88, %71
%117 = load i32, i32* %10
%118 = icmp ugt i32 %117, 0
br i1 %118, label %119, label %147
119: ; preds = %116
%120 = load i32, i32* %10
%121 = sub i32 %120, 1
%122 = zext i32 %121 to i64
%123 = getelementptr inbounds [20 x [21 x i8]], [20 x [21 x i8]]* %5, i64 0, i64 %122
%124 = load i32, i32* %9
%125 = zext i32 %124 to i64
%126 = getelementptr inbounds [21 x i8], [21 x i8]* %123, i64 0, i64 %125
%127 = load i8, i8* %126
%128 = sext i8 %127 to i32
%129 = icmp eq i32 46, %128
br i1 %129, label %130, label %147
130: ; preds = %119
%131 = load i32, i32* %9
%132 = load i32, i32* %10
%133 = sub i32 %132, 1
%134 = shl i32 %133, 16
%135 = add i32 %131, %134
%136 = load i32, i32* %8
%137 = add i32 %136, 1
store i32 %137, i32* %8
%138 = zext i32 %136 to i64
%139 = getelementptr inbounds [400 x i32], [400 x i32]* %6, i64 0, i64 %138
store i32 %135, i32* %139
%140 = load i32, i32* %10
%141 = sub i32 %140, 1
%142 = zext i32 %141 to i64
%143 = getelementptr inbounds [20 x [21 x i8]], [20 x [21 x i8]]* %5, i64 0, i64 %142
%144 = load i32, i32* %9
%145 = zext i32 %144 to i64
%146 = getelementptr inbounds [21 x i8], [21 x i8]* %143, i64 0, i64 %145
store i8 64, i8* %146
br label %147
147: ; preds = %130, %119, %116
%148 = load i32, i32* %9
%149 = icmp ugt i32 %148, 0
br i1 %149, label %150, label %178
150: ; preds = %147
%151 = load i32, i32* %10
%152 = zext i32 %151 to i64
%153 = getelementptr inbounds [20 x [21 x i8]], [20 x [21 x i8]]* %5, i64 0, i64 %152
%154 = load i32, i32* %9
%155 = sub i32 %154, 1
%156 = zext i32 %155 to i64
%157 = getelementptr inbounds [21 x i8], [21 x i8]* %153, i64 0, i64 %156
%158 = load i8, i8* %157
%159 = sext i8 %158 to i32
%160 = icmp eq i32 46, %159
br i1 %160, label %161, label %178
161: ; preds = %150
%162 = load i32, i32* %9
%163 = sub i32 %162, 1
%164 = load i32, i32* %10
%165 = shl i32 %164, 16
%166 = add i32 %163, %165
%167 = load i32, i32* %8
%168 = add i32 %167, 1
store i32 %168, i32* %8
%169 = zext i32 %167 to i64
%170 = getelementptr inbounds [400 x i32], [400 x i32]* %6, i64 0, i64 %169
store i32 %166, i32* %170
%171 = load i32, i32* %10
%172 = zext i32 %171 to i64
%173 = getelementptr inbounds [20 x [21 x i8]], [20 x [21 x i8]]* %5, i64 0, i64 %172
%174 = load i32, i32* %9
%175 = sub i32 %174, 1
%176 = zext i32 %175 to i64
%177 = getelementptr inbounds [21 x i8], [21 x i8]* %173, i64 0, i64 %176
store i8 64, i8* %177
br label %178
178: ; preds = %161, %150, %147
%179 = load i32, i32* %10
%180 = add i32 %179, 1
%181 = load i32, i32* %4
%182 = icmp ult i32 %180, %181
br i1 %182, label %183, label %211
183: ; preds = %178
%184 = load i32, i32* %10
%185 = add i32 %184, 1
%186 = zext i32 %185 to i64
%187 = getelementptr inbounds [20 x [21 x i8]], [20 x [21 x i8]]* %5, i64 0, i64 %186
%188 = load i32, i32* %9
%189 = zext i32 %188 to i64
%190 = getelementptr inbounds [21 x i8], [21 x i8]* %187, i64 0, i64 %189
%191 = load i8, i8* %190
%192 = sext i8 %191 to i32
%193 = icmp eq i32 46, %192
br i1 %193, label %194, label %211
194: ; preds = %183
%195 = load i32, i32* %9
%196 = load i32, i32* %10
%197 = add i32 %196, 1
%198 = shl i32 %197, 16
%199 = add i32 %195, %198
%200 = load i32, i32* %8
%201 = add i32 %200, 1
store i32 %201, i32* %8
%202 = zext i32 %200 to i64
%203 = getelementptr inbounds [400 x i32], [400 x i32]* %6, i64 0, i64 %202
store i32 %199, i32* %203
%204 = load i32, i32* %10
%205 = add i32 %204, 1
%206 = zext i32 %205 to i64
%207 = getelementptr inbounds [20 x [21 x i8]], [20 x [21 x i8]]* %5, i64 0, i64 %206
%208 = load i32, i32* %9
%209 = zext i32 %208 to i64
%210 = getelementptr inbounds [21 x i8], [21 x i8]* %207, i64 0, i64 %209
store i8 64, i8* %210
br label %211
211: ; preds = %194, %183, %178
br label %67
212: ; preds = %67
%213 = load i32, i32* %8
ret i32 %213
}

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