Problem:


Score : 500 points

Problem Statement

Alice and Brown loves games. Today, they will play the following game.

In this game, there are two piles initially consisting of X and Y stones, respectively.
Alice and Bob alternately perform the following operation, starting from Alice:

Take 2i stones from one of the piles. Then, throw away i of them, and put the remaining i in the other pile. Here, the integer i (1≤i) can be freely chosen as long as there is a sufficient number of stones in the pile.

The player who becomes unable to perform the operation, loses the game.

Given X and Y, determine the winner of the game, assuming that both players play optimally.

Constraints

0 ≤ X, Y ≤ 10^{18}

Input

Input is given from Standard Input in the following format:

X Y

Output

Print the winner: either Alice or Brown.

Sample Input 1

2 1

Sample Output 1

Brown

Alice can do nothing but taking two stones from the pile containing two stones. As a result, the piles consist of zero and two stones, respectively. Then, Brown will take the two stones, and the piles will consist of one and zero stones, respectively. Alice will be unable to perform the operation anymore, which means Brown's victory.

Sample Input 2

5 0

Sample Output 2

Alice

Sample Input 3

0 0

Sample Output 3

Brown

Sample Input 4

4 8

Sample Output 4

Alice



Sample input:
2 1


Sample output:
Brown

Submission status: Accepted

Solution code:
# editorial

def main():
    X, Y = map(int, input().split())

    def solve(x, y):
        """手番が勝つか"""
        return not ((X + Y <= 1) or (abs(X - Y) <= 1))

    cond = solve(X, Y)
    print('Alice' if cond else 'Brown')


if __name__ == '__main__':
    main()

# e,e
# o,e
# o,o
# o,e遷移は今回は関係なかった

# 負け状態
# 0,0
# 0,1
# 1,1
# まとめると
# X+Y<=1
# abs(X-Y)<=1 <-> >1 と交互

# まとめ方
# 偶奇
# 和と差

Submission status: Accepted

Solution code:
#!/usr/bin/env python3

import sys
# import time
# import math
# import numpy as np
# import scipy.sparse.csgraph as cs            # csgraph_from_dense(ndarray, null_value=inf), bellman_ford(G, return_predecessors=True), dijkstra, floyd_warshall
# import random                                # random, uniform, randint, randrange, shuffle, sample
# import string                                # ascii_lowercase, ascii_uppercase, ascii_letters, digits, hexdigits
# import re                                    # re.compile(pattern) => ptn obj; p.search(s), p.match(s), p.finditer(s) => match obj; p.sub(after, s)
# from bisect import bisect_left, bisect_right # bisect_left(a, x, lo=0, hi=len(a)) returns i such that all(val<x for val in a[lo:i]) and all(val>-=x for val in a[i:hi]).
# from collections import deque                # deque class. deque(L): dq.append(x), dq.appendleft(x), dq.pop(), dq.popleft(), dq.rotate()
# from collections import defaultdict          # subclass of dict. defaultdict(facroty)
# from collections import Counter              # subclass of dict. Counter(iter): c.elements(), c.most_common(n), c.subtract(iter)
# from datetime import date, datetime          # date.today(), date(year,month,day) => date obj; datetime.now(), datetime(year,month,day,hour,second,microsecond) => datetime obj; subtraction => timedelta obj
# from datetime.datetime import strptime       # strptime('2019/01/01 10:05:20', '%Y/%m/%d/ %H:%M:%S') returns datetime obj
# from datetime import timedelta               # td.days, td.seconds, td.microseconds, td.total_seconds(). abs function is also available.
# from copy import copy, deepcopy              # use deepcopy to copy multi-dimentional matrix without reference
# from functools import reduce                 # reduce(f, iter[, init])
# from functools import lru_cache              # @lrucache ...arguments of functions should be able to be keys of dict (e.g. list is not allowed)
# from heapq import heapify, heappush, heappop # built-in list. heapify(L) changes list in-place to min-heap in O(n), heappush(heapL, x) and heappop(heapL) in O(lgn).
# from heapq import nlargest, nsmallest        # nlargest(n, iter[, key]) returns k-largest-list in O(n+klgn).
# from itertools import count, cycle, repeat   # count(start[,step]), cycle(iter), repeat(elm[,n])
# from itertools import groupby                # [(k, list(g)) for k, g in groupby('000112')] returns [('0',['0','0','0']), ('1',['1','1']), ('2',['2'])]
# from itertools import starmap                # starmap(pow, [[2,5], [3,2]]) returns [32, 9]
# from itertools import product, permutations  # product(iter, repeat=n), permutations(iter[,r])
# from itertools import combinations, combinations_with_replacement
# from itertools import accumulate             # accumulate(iter[, f])
# from operator import itemgetter              # itemgetter(1), itemgetter('key')
# from fractions import gcd                    # for Python 3.4 (previous contest @AtCoder)



def main():
    mod = 1000000007                # 10^9+7
    inf = float('inf')              # sys.float_info.max = 1.79...e+308
    # inf = 2 ** 64 - 1             # (for fast JIT compile in PyPy) 1.84...e+19
    sys.setrecursionlimit(10**6)    # 1000 -> 1000000
    def input(): return sys.stdin.readline().rstrip()
    def ii():    return int(input())
    def mi():    return map(int, input().split())
    def mi_0():  return map(lambda x: int(x)-1, input().split())
    def lmi():   return list(map(int, input().split()))
    def lmi_0(): return list(map(lambda x: int(x)-1, input().split()))
    def li():    return list(input())
    
    
    x, y = mi()
    print('Brown') if abs(x - y) <= 1 else print('Alice')


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
x,y=map(int,input().split())
if x>y:
  x,y=y,x
  
if y-x<=1:
  print("Brown")
else:
  print("Alice")

Submission status: Accepted

Solution code:
X, Y = map(int, input().split())

print('Brown' if abs(X - Y) < 2 else 'Alice')

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
import sys
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
input=lambda: sys.stdin.readline().rstrip()
YesNo=lambda b: bool([print('Yes')] if b else print('No'))
YESNO=lambda b: bool([print('YES')] if b else print('NO'))
int1=lambda x:int(x)-1

def main():
    X,Y=map(int,input().split())
    if abs(X-Y)<=1:
        print('Brown')
    else:
        print('Alice')

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
x, y = map(int, input().split())
if abs(x-y) <= 1:
    print('Brown')
else:
    print('Alice')

Submission status: Accepted

Solution code:
import sys
import heapq, math
from itertools import zip_longest, permutations, combinations, combinations_with_replacement
from itertools import accumulate, dropwhile, takewhile, groupby
from functools import lru_cache
from copy import deepcopy


X, Y = map(int, input().split())

print("Brown" if abs(X - Y) <= 1 else "Alice")

Submission status: Accepted

Solution code:
X, Y = map(int, input().split())

print('Alice' if abs(X - Y) > 1 else 'Brown')

Submission status: Accepted

Solution code:
X,Y = map(int,input().split())
if abs(X-Y)>=2:
    print("Alice")
else:
    print("Brown")

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline
from collections import *

"""
def dfs(x, y):
    if x<=1 and y<=1:
        return False
    
    res = False
    
    for i in range(2, x+1, 2):
        res |= not dfs(x-i, y+i//2)
    
    for i in range(2, y+1, 2):
        res |= not dfs(x+i//2, y-i)
    
    return res

for i in range(5):
    for j in range(5):
        print(dfs(i, j), end=' ')
    
    print()
"""

X, Y = map(int, input().split())

if abs(X-Y)<=1:
    print('Brown')
else:
    print('Alice')

Submission status: Accepted

Solution code:
X, Y = map(int, input().split())
if abs(X - Y) > 1:
  print("Alice")
else:
  print("Brown")

Submission status: Accepted

Solution code:
X,Y = map(int,input().split())

print("Brown" if abs(X-Y) <= 1 else "Alice")

Submission status: Accepted

Solution code:
x,y = map(int, input().split())

if abs(x-y)>1:
    print("Alice")
else:
    print("Brown")

Submission status: Accepted

Solution code:
X,Y=map(int,input().split())
X,Y=max(X,Y),min(X,Y)
#print(X,Y)

if X<=1:
  print("Brown")
else:
  if X-Y>=2:
    print("Alice")
  else:
    print("Brown")

Submission status: Accepted

Solution code:
x,y = map(int,input().split())

print("Alice" if abs(x-y)>1 else "Brown")

Submission status: Accepted

Solution code:
x,y=map(int,input().split())
if abs(x-y)>=2:
  print("Alice")
else:
  print("Brown")

Submission status: Accepted

Solution code:
X, Y = map(int, input().split())
print("Brown" if abs(X - Y) <= 1 else 'Alice')

Submission status: Accepted

Solution code:
x,y = map(int, input().split())

if abs(x-y) <= 1:
  print("Brown")
else:
  print("Alice")

Submission status: Accepted

Solution code:
def main():
    x, y = map(int, input().split())
    if abs(x-y) <= 1:
        print("Brown")
    else:
        print("Alice")

if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
X, Y = map(int, input().split())
if abs(X - Y) <= 1:
  print('Brown')
else:
  print('Alice')

Submission status: Accepted

Solution code:
import sys
import math
from collections import defaultdict
from bisect import bisect_left, bisect_right

sys.setrecursionlimit(10**7)
def input():
    return sys.stdin.readline()[:-1]

mod = 10**9 + 7

def I(): return int(input())
def LI(): return list(map(int, input().split()))
def LIR(row,col):
    if row <= 0:
        return [[] for _ in range(col)]
    elif col == 1:
        return [I() for _ in range(row)]
    else:
        read_all = [LI() for _ in range(row)]
        return map(list, zip(*read_all))

#################

# [a,a],[a,a-1]が負け状況

X,Y = LI()
if abs(X-Y) == 1 or abs(X-Y) == 0:
    print('Brown')
else:
    print('Alice')

Submission status: Accepted

Solution code:
X,Y=map(int,input().split())
if abs(X-Y)>1:
    print('Alice')
else:
    print('Brown')

Submission status: Accepted

Solution code:
x, y = map(int, input().split())

print("Alice" if abs(x - y) > 1 else "Brown")

Submission status: Accepted

Solution code:
# solution
import io

nim,mike = map(int,input().split())
print("Brown" if abs(nim-mike)<2 else "Alice")

Submission status: Accepted

Solution code:
x,y= map(int,input().split())
result=abs(x-y)


if result <=1:
    print("Brown")
else:
    print("Alice")

Submission status: Accepted

Solution code:
a,b=map(int,input().split())
cnt=1
if abs(a-b)<=1:
    print('Brown')
else:
    print('Alice')


# if b>a:
#     a,b=b,a
# a=a-b
# b=0
# mod_a=a%3
# if a==3:
#     print('Alice')
# elif mod_a==2:
#     print('Alice')
# elif mod_a==1:
#     print('Brown')
# elif (mod_a==0)and(a!=3):
#     print('Brown')
# if (mod_a==3)and(mod_b==3):
#     print('Alice')
# elif (mod_a==3)and(mod_b==1):
#     print('Alice')
# elif (mod_a==1)and(mod_b==3):
#     print('Alice')
# elif (mod_a==2)and(mod_b==0):
#     print('Alice')    
# elif (mod_a==0)and(mod_b==2):
#     print('Alice')
# else:
#     print('Brown')

Submission status: Accepted

Solution code:
X, Y = map(int, input().split())
if abs(X - Y) <= 1:
    print('Brown')
else:
    print('Alice')

Submission status: Accepted

Solution code:
X, Y = map(int, input().split())
ans = 'Brown' if abs(X - Y) <= 1 else 'Alice'
print(ans)

Submission status: Accepted

Solution code:
X,Y=map(int,input().split())
if X+Y<2 or abs(X-Y)<2: print("Brown")
else : print("Alice")

Submission status: Accepted

Solution code:
# 解説AC
X,Y = map(int, input().split())
print("Alice" if abs(X - Y) > 1 else "Brown")

Submission status: Accepted

Solution code:
x,y=map(int,input().split())
print('Brown' if abs(x-y)<=1 else 'Alice')

Submission status: Accepted

Solution code:
x, y = map(int, input().split())

if abs(x-y) <= 1:
    print("Brown")
else:
    print("Alice")

Submission status: Accepted

Solution code:
x,y = map(int,input().split())
if abs(x - y) > 1:
  print("Alice")
else:
  print("Brown")

Submission status: Accepted

Solution code:
def solve():
    x, y = map(int, input().split())
    if abs(x - y) <= 1:
        print('Brown')
    else:
        print('Alice')


if __name__ == '__main__':
    solve()

Submission status: Accepted

Solution code:
X,Y=map(int,input().split())
if abs(X-Y)>1:
    print("Alice")
else:
    print("Brown")

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
import sys


def solve(X: int, Y: int):
    return 'Alice' if abs(X-Y) > 1 else 'Brown'


# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools  (tips: You use the default template now. You can remove this line by using your custom template)
def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    X = int(next(tokens))  # type: int
    Y = int(next(tokens))  # type: int
    print(solve(X, Y))

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
x, y = map(int, input().split())
if abs(x - y) < 2:
    print('Brown')
else:
    print('Alice')

Submission status: Accepted

Solution code:
X, Y = map(int,input().split())
print('Brown' if abs(X - Y) <= 1 else 'Alice')

Submission status: Accepted

Solution code:
#一問目
x,y=map(int,input().split())
if abs(x-y)<=1:
    print("Brown")
else:
    print("Alice")

Submission status: Accepted

Solution code:
x, y = map(int, input().split())

if abs(x - y) <= 1:
    ans = "Brown"
else:
    ans = "Alice"

print(ans)

Submission status: Accepted

Solution code:
a,b=map(int,input().split())
if -2<a-b<2:print("Brown")
else:print("Alice")

Submission status: Accepted

Solution code:
import sys
def main():
    input = sys.stdin.readline
    X,Y = map(int, input().split())
    if X>Y: X,Y = Y,X

    if X==Y or Y-X==1:
        print('Brown')
    else:
        print('Alice')

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import sys

def solve():
    input = sys.stdin.readline
    X, Y = map(int, input().split())
    if abs(X - Y) > 1: print("Alice")
    else: print("Brown")

    return 0

if __name__ == "__main__":
    solve()

Submission status: Accepted

Solution code:
X, Y = map(int, input().split())
if abs(X - Y) > 1:
    print('Alice')
else:
    print('Brown')

Submission status: Accepted

Solution code:
x, y = map(int, input().split())

print('Brown' if abs(x - y) <= 1 else 'Alice')

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline

def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))

def main():
    mod=10**9+7
    x,y=MI()
    
    if abs(x-y)<=1:
        print("Brown")
    else:
        print("Alice")
                

main()

Submission status: Accepted

Solution code:
x,y = map(int,input().split())
if abs(x-y) <= 1:
    print("Brown")
else:
    print("Alice")
# a:x+y >1 , abs(x-y)>1
# b:x+y >1 , abs(x-y) <=1
# c:x+y <=1, (abs(x-y) <=1  )　--> lose
#
#       c <--- a <---> b
#       a <---> a

Submission status: Accepted

Solution code:
print("ABlriocwen"[-2<eval(input().replace(" ","-"))<2::2])

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
import sys


def solve(X: int, Y: int):
    print("Brown" if -1 <= X - Y <= 1 else "Alice")


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    X = int(next(tokens))  # type: int
    Y = int(next(tokens))  # type: int
    solve(X, Y)


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import sys

sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))

X, Y = lr()

if abs(Y - X) >= 2:
    print('Alice')
else:
    print('Brown')

# 24

Submission status: Accepted

Solution code:
x,y = map(int, input().split())
if abs(x - y) <= 1:
    print("Brown")
else:
    print("Alice")

Submission status: Accepted

Solution code:
x,y=map(int,input().split())
if abs(x-y)<=1:
  print('Brown')
else:
  print('Alice')

Submission status: Accepted

Solution code:
#01:25
a,b = map(int,input().split())
if abs(a-b) <= 1:
  print('Brown')
else:
  print('Alice')

Submission status: Accepted

Solution code:
X, Y = map(int,input().split())
if abs(X-Y) <=1:
  print('Brown')
else:
  print('Alice')

Submission status: Accepted

Solution code:
X, Y = map(int, input().split())
print("Brown" if abs(X-Y) <= 1 else "Alice")

Submission status: Accepted

Solution code:
import sys

sys.setrecursionlimit(10 ** 6)
def MI(): return map(int, sys.stdin.readline().split())

def main():
    x,y=MI()
    if x>y:x,y=y,x
    if y>x+1:print("Alice")
    else:print("Brown")

main()

Submission status: Accepted

Solution code:
X, Y = map(int, input().split())
print('Alice' if abs(X-Y)>=2 else 'Brown')

Submission status: Accepted

Solution code:
X,Y = map(int,input().split())

if abs(X-Y) <= 1:
  print ("Brown")
else:
  print ("Alice")

Submission status: Accepted

Solution code:
x,y=map(int,input().split())
if abs(x-y)<=1:
  print("Brown")
else:
  print("Alice")

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline

x,y=map(int,input().split())
print("Brown" if y-1<=x<=y+1 else "Alice")

Submission status: Accepted

Solution code:
x,y=map(int,input().split())
a=abs(x-y)
if a==0 or a==1:
  print("Brown")
else:
  print("Alice")

Submission status: Accepted

Solution code:
a,b=map(int,input().split())
if abs(a-b)<=1:
  print("Brown")
else:
  print("Alice")

Submission status: Accepted

Solution code:
x,y=map(int,input().split())
print("Alice" if abs(x-y)>1 else "Brown")

Submission status: Accepted

Solution code:
x, y = map(int, input().split())
print('Alice' if abs(x-y) > 1 else 'Brown')

Submission status: Accepted

Solution code:
X, Y = map(int, input().split())

if abs(X - Y) <= 1:
    print ('Brown')
else:
    print ('Alice')

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-

import sys

def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7

X, Y = MAP()

memo = list2d(1007, 1007, -1)
def rec(x, y):
    if memo[x][y] != -1:
        return memo[x][y]
    if x < 2 and y < 2:
        memo[x][y] = 0
        return 0
    res = 0
    for i in range(2, x+1):
        if not rec(x - i, y + i//2):
            res = 1
    for i in range(2, y+1):
        if not rec(x + i//2, y - i):
            res = 1
    memo[x][y] = res
    return res

# for i in range(X+1):
#     for j in range(Y+1):
#         rec(i, j)
# for i in range(X+1):
#     print(memo[i][:Y+1])

if abs(X - Y) >= 2:
    print('Alice')
else:
    print('Brown')

Submission status: Accepted

Solution code:
a,b = map(int, input().split())
print('Alice' if abs(a-b) > 1 else 'Brown')

Submission status: Accepted

Solution code:
x, y = map(int, input().split())
if -1 <= x-y <= 1:
  print("Brown")
else:
  print("Alice")

Submission status: Accepted

Solution code:
a,b = map(int, input().split())
if abs(a-b) <= 1:
  print("Brown")
else:
  print("Alice")

Submission status: Accepted

Solution code:
x, y = map(int,input().split())

if abs(x-y) <= 1:
  print("Brown")
else:
  print("Alice")

Submission status: Accepted

Solution code:
x, y = map(int, input().split())
if abs(x - y) <= 1:
    print('Brown')
else:
    print('Alice')

Submission status: Accepted

Solution code:
import sys

x, y = map(int, sys.stdin.readline().split())

def main():
    return  'Brown' if abs(x - y) <= 1 else 'Alice'

if __name__ == '__main__':
    ans = main()
    print(ans)

Submission status: Accepted

Solution code:
x, y = map(int, input().split())
print('Brown' if abs(x - y) <= 1 else 'Alice')

# 総和<=1なら後手勝利（ベース）
# 総和>1かつ差<=1なら、どうしても差>1で相手に手を渡すことになるが、
#   総和>1が確定するので、後手の負けはない
# 総和>1かつ差>1なら、差<=1にできるが、
#   このとき、総和<=1になれば、後手に負けを押し付けられるので、先手勝利

# 総和>1かつ初手で差>1なら、相手に差<=1を押し付けられるので、自分の負けはなく、
# 差<=1を押し付け続けながら、総和<=1にできるのを待てばよいので、先手必勝

# 総和>1かつ初手で差<=1なら、後手は差>1を持てるので、後手必勝
# また、総和<=1のとき、後手必勝だが、差<=1を満たす

# 初手の差で決まる

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline

def main():
    x,y = map(int, input().split())
    ans = "Brown"
    if abs(x-y) > 1:
        ans = "Alice"
    print(ans)


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
X, Y = map(int, input().split())

if abs(X - Y) > 1:
    print("Alice")
else:
    print("Brown")

Submission status: Accepted

Solution code:
X, Y = map(int, input().split())

if (X - Y) ** 2 > 1:
    print("Alice")
else:
    print("Brown")

Submission status: Accepted

Solution code:
X, Y = map(int, input().split())
if abs(X - Y) <= 1:
    print("Brown")
else:
    print("Alice")

Submission status: Accepted

Solution code:
x, y = map(int, input().split())
print('Alice') if abs(x - y) > 1 else print('Brown')

Submission status: Accepted

Solution code:
def main():
    x,y=map(int,input().split())
    if x==y:
        print("Brown")
    elif abs(x-y)%3==0:
        print("Alice")
    elif abs(x-y)==1:
        print("Brown")
    else:
        print("Alice")
main()

Submission status: Accepted

Solution code:
x, y = map(int, input().split())
 
if abs(x - y) <= 1:print('Brown')
else:
  print('Alice')

Submission status: Accepted

Solution code:
x,y=[int(i) for i in input().split()]
if(abs(x-y)<=1):
    print('Brown')
else:
    print('Alice')

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda :sys.stdin.readline().rstrip()
def resolve():
    x,y=map(int,input().split())
    print("Alice" if(abs(x-y)>1) else "Brown")
resolve()

Submission status: Accepted

Solution code:
X,Y = map(int, input().split())

if abs(X-Y) > 1:
    print("Alice")
else:
    print("Brown")

Submission status: Accepted

Solution code:
x,y=map(int,input().split())
if abs(x-y)>1:
    print("Alice")
else:
    print("Brown")

Submission status: Accepted

Solution code:
x,y=map(int,input().split())
if abs(x - y) >= 2:
  print("Alice") 
else:
  print("Brown")

Submission status: Accepted

Solution code:
def examD():
    X, Y =LI()
    if abs(X-Y)<=1:
        ans = "Brown"
    else:
        ans = "Alice"
    print(ans)

import sys
import copy
import bisect
from collections import Counter,defaultdict,deque
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def S(): return sys.stdin.readline().strip()
mod = 10**9 + 7
inf = float('inf')

examD()

Submission status: Accepted

Solution code:
x, y = [int(i) for i in input().split()]

print("Alice") if abs(x - y) >= 2 else print("Brown")

Submission status: Accepted

Solution code:
a,b=map(int,input().split())
print('Alice' if abs(a-b)>1 else 'Brown')

Submission status: Accepted

Solution code:
X, Y = map(int, input().split())
if abs(Y-X)<=1:
    print('Brown')
else:
    print('Alice')

Submission status: Accepted

Solution code:
X,Y = map(int,input().split())
if X==Y or abs(X-Y)==1:
    print("Brown")
else:
    print("Alice")

Submission status: Accepted

Solution code:
X, Y = map(int, input().split())

if abs(X-Y) < 2:
    print('Brown')
else:
    print('Alice')

Submission status: Accepted

Solution code:
x, y = map(int, input().split())
if abs(x - y) <= 1:
  print("Brown")
else:
  print("Alice")

Submission status: Accepted

Solution code:
print(['Alice','Brown'][abs(eval(input().replace(' ','-')))<2])

Submission status: Accepted

Solution code:
X, Y = map(int, input().split())
print("Alice" if abs(X-Y)>=2 else "Brown")

Submission status: Accepted

Solution code:
x,y=map(int,input().split())
if abs(x-y)<=1:
    print("Brown")
else:
    print("Alice")

Submission status: Accepted

Solution code:
x,y=map(int, input().split())
if abs(x-y) <= 1 :
    print('Brown')
else:
    print('Alice')

Submission status: Accepted

Solution code:
x, y = map(int, input().split())
print("Alice" if abs(x - y) > 1 else "Brown")

Submission status: Accepted

Solution code:
x, y = map(int, input().split())

if (abs(x - y) > 1):
    print("Alice")
else:
    print("Brown")

Submission status: Accepted

Solution code:
X, Y = map(int, input().split())
print('Alice') if abs(X - Y) > 1 else print('Brown')

Submission status: Accepted

Solution code:
x, y = map(int,input().split())
print("Brown" if abs(x-y) <= 1 else "Alice")

Submission status: Accepted

Solution code:
import sys
def main():
    def input():
        return sys.stdin.readline()[:-1]

    X, Y = map(int,input().split())
    print("Brown" if abs(X-Y) <= 1 else "Alice")

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
#ABC59 D

import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(1000000000)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))

x,y = LI()
if abs(x-y) <= 1:
    print('Brown')
else:
    print('Alice')

Submission status: Accepted

Solution code:
X, Y = [int(_) for _ in input().split()]
print('Brown' if abs(X - Y) < 2 else 'Alice')

Submission status: Accepted

Solution code:
X,Y=map(int,input().split())
A,B=X,Y
while A>=2 or B>=2:
    if A>B:
        a = A//2
        A-=2*a
        B+=a
    else:
        b = B//2
        B-=2*b
        A+=b
if X-Y == A-B:
    print("Brown")
else:
    print("Alice")

Submission status: Accepted

Solution code:
def main():

    X, Y = map(int, input().split())
    if X + Y <= 1: # no further move possible at the begining
        return "Brown"
    elif abs(X-Y) <= 1: # opponent's next turn satisfies abs(X-Y) > 1
        return "Brown"
    else: # can always choose such that the opponent's next turn satisfied abs(X-Y) <= 1
        return "Alice"  

if __name__ == '__main__':
    print(main())

Submission status: Accepted

Solution code:
x,y=map(int,input().split())
if abs(x-y)<2:
  print('Brown')
else:
  print('Alice')

Submission status: Accepted

Solution code:
X,Y = map(int, input().split())
print("Brown" if abs(X-Y) <= 1 else "Alice")

Submission status: Accepted

Solution code:
x , y = map(int , input().split())
if abs(x - y) > 1:
    print("Alice")
else:
    print("Brown")

Submission status: Accepted

Solution code:
x, y = map(int, input().split(' '))

if abs(x-y) <= 1:
    print('Brown')
else:
    print('Alice')

Submission status: Accepted

Solution code:
X, Y = map(int, input().split())
print("Brown" if abs(X - Y) < 2 else "Alice")

Submission status: Accepted

Solution code:
x,y = map(int,input().split())
print("Brown") if abs(x-y) < 2 else print("Alice")

Submission status: Accepted

Solution code:
#!usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
import itertools
sys.setrecursionlimit(10**5)
stdin = sys.stdin
bisect_left = bisect.bisect_left
bisect_right = bisect.bisect_right
def LI(): return list(map(int, stdin.readline().split()))
def LF(): return list(map(float, stdin.readline().split()))
def LI_(): return list(map(lambda x: int(x)-1, stdin.readline().split()))
def II(): return int(stdin.readline())
def IF(): return float(stdin.readline())
def LS(): return list(map(list, stdin.readline().split()))
def S(): return list(stdin.readline().rstrip())
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float('INF')

#A
def A():
    a = input().split()
    a = list(map(lambda x: x.capitalize(), a))
    a,b,c = a
    print(a[0]+b[0]+c[0])
    return

#B
def B():
    a = II()
    b = II()
    if a > b:
        print("GREATER")
    if a < b:
        print("LESS")
    if a == b:
        print("EQUAL")
    return

#C
def C():
    II()
    a = LI()
    def f(suma, b):
        for i in a[1:]:
            if suma * (suma + i) < 0:
                suma += i
                continue
            b += (abs(suma + i) + 1)
            suma = (-1 * (suma > 0)) or 1
        return b

    if a[0] == 0:
        ans = min(f(1, 1), f(-1, 1))
    else:
        ans = min(f(a[0], 0), f(1 * (a[0] < 0) or - 1, abs(a[0]) + 1))
    print(ans)
    return

#D
def D_():
    s = S()
    for i in range(len(s) - 1):
        if s[i] == s[i+1]:
            print(i + 1, i + 2)
            return
    for i in range(len(s) - 2):
        if s[i] == s[i + 2]:
            print(i + 1, i + 3)
            return
    print(-1, -1)

def D():
    x, y = LI()
    a = abs(x - y)
    if a <= 1:
        print("Brown")
    else:
        print("Alice")
    return


#Solve
if __name__ == '__main__':
    D()

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
import sys
INF = float("inf")


def solve(X: int, Y: int):

    if abs(X-Y) <= 1:
        print("Brown")
    else:
        print("Alice")
    return


def main():

    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    X = int(next(tokens))  # type: int
    Y = int(next(tokens))  # type: int
    solve(X, Y)


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
x,y=map(int,input().split())
print("Alice"if abs(x-y)>1else"Brown")

Submission status: Accepted

Solution code:
# coding: utf-8
# Your code here!

import sys
sys.setrecursionlimit(10**6)
readline = sys.stdin.readline #文字列入力のときは注意

#n = int(input())
x,y = [int(i) for i in readline().split()]

if abs(x-y) <= 1:
    print("Brown")
else:
    print("Alice")

"""
n = 50
dp = [[0]*n for i in range(n)]

dp[1][1] = -1 

def dfs(i,j):
    if dp[i][j] != 0: return dp[i][j]
    for k in range(1,i//2+1):
        if dfs(i-2*k,j+k) == -1:
            dp[i][j] = 1
            return 1
    for k in range(1,j//2+1):
        if dfs(i+k,j-2*k) == -1:
            dp[i][j] = 1
            return 1
    dp[i][j] = -1
    return -1
        
for i in range(10):
    for j in range(10):
        dfs(i,j)


print(*dp, sep="\n")
"""

Submission status: Accepted

Solution code:
a,b=map(int,input().split())
if abs(a-b)<=1:
  print('Brown')
else:
  print('Alice')

Submission status: Accepted

Solution code:
X, Y = map(int, input().split())

if abs(X - Y) <= 1:
    print('Brown')
else:
    print('Alice')

Submission status: Accepted

Solution code:
X, Y = map(int, input().split())

if abs(X-Y) <= 1 :
    print('Brown')
else :
    print('Alice')

Submission status: Accepted

Solution code:
X,Y = (int(x) for x in input().split())

if abs(X-Y) < 2:
    print("Brown")
else:
    print("Alice")

Submission status: Accepted

Solution code:
import sys
input=sys.stdin.readline
x,y=map(int,input().split())
g=max(x,y)-min(x,y)
if g==0 or g==1:
    print('Brown')
else:
    print('Alice')