Problem:
 Score : 300 points    Problem Statement A game is played on a strip consisting of N cells consecutively numbered from 1 to N .  Alice has her token on cell A . Borys has his token on a different cell B .  Players take turns, Alice moves first.
The moving player must shift his or her token from its current cell X to the neighboring cell on the left, cell X-1 , or on the right, cell X+1 .
Note that it's disallowed to move the token outside the strip or to the cell with the other player's token.
In one turn, the token of the moving player must be shifted exactly once.  The player who can't make a move loses, and the other player wins.  Both players want to win. Who wins if they play optimally?      Constraints  2 \leq N \leq 100  1 \leq A < B \leq N  All input values are integers.         Input Input is given from Standard Input in the following format:  N  A  B       Output Print Alice if Alice wins, Borys if Borys wins, and Draw if nobody wins.        Sample Input 1 5 2 4      Sample Output 1 Alice  Alice can move her token to cell 3. 
After that, Borys will be unable to move his token to cell 3, so he will have to move his token to cell 5. 
Then, Alice moves her token to cell 4. Borys can't make a move and loses.       Sample Input 2 2 1 2      Sample Output 2 Borys  Alice can't make the very first move and loses.       Sample Input 3 58 23 42      Sample Output 3 Borys

Solution (Python):

import sys
import math
import os
import itertools
import string
import heapq
import _collections
from collections import Counter
from collections import defaultdict
from functools import lru_cache
import bisect
import re
import queue


class Scanner():
    @staticmethod
    def int():
        return int(sys.stdin.readline().rstrip())

    @staticmethod
    def string():
        return sys.stdin.readline().rstrip()

    @staticmethod
    def map_int():
        return [int(x) for x in Scanner.string().split()]

    @staticmethod
    def string_list(n):
        return [input() for i in range(n)]

    @staticmethod
    def int_list_list(n):
        return [Scanner.map_int() for i in range(n)]

    @staticmethod
    def int_cols_list(n):
        return [int(input()) for i in range(n)]


class Math():
    @staticmethod
    def gcd(a, b):
        if b == 0:
            return a
        return Math.gcd(b, a % b)

    @staticmethod
    def lcm(a, b):
        return (a * b) // Math.gcd(a, b)

    @staticmethod
    def roundUp(a, b):
        return -(-a // b)

    @staticmethod
    def toUpperMultiple(a, x):
        return Math.roundUp(a, x) * x

    @staticmethod
    def toLowerMultiple(a, x):
        return (a // x) * x

    @staticmethod
    def nearPow2(n):
        if n <= 0:
            return 0
        if n & (n - 1) == 0:
            return n
        ret = 1
        while(n > 0):
            ret <<= 1
            n >>= 1
        return ret

    @staticmethod
    def sign(n):
        if n == 0:
            return 0
        if n < 0:
            return -1
        return 1

    @staticmethod
    def isPrime(n):
        if n < 2:
            return False
        if n == 2:
            return True
        if n % 2 == 0:
            return False
        d = int(n ** 0.5) + 1
        for i in range(3, d + 1, 2):
            if n % i == 0:
                return False
        return True


class PriorityQueue:
    def __init__(self, l=[]):
        self.__q = l
        heapq.heapify(self.__q)
        return

    def push(self, n):
        heapq.heappush(self.__q, n)
        return

    def pop(self):
        return heapq.heappop(self.__q)


MOD = int(1e09) + 7
INF = int(1e15)


def main():
    
    N, A, B = Scanner.map_int()
    winner = ""
    while True:
        if A + 1 == B:
            A -= 1
        else:
            A += 1
        if B - 1 == A:
            B += 1
        else:
            B -= 1
        if A < 0:
            winner = "Borys"
            break
        elif B >= N:
            winner = "Alice"
            break
    print(winner)
    return


if __name__ == "__main__":
    main()

Solution (Python):
N , A, B = map(int,input().split())
if (A - B) % 2 == 0:
	print("Alice")
else:
	print("Borys")

Solution (Python):
N,A,B = map(int,input().split())
if (A-B)%2 == 0:
    print("Alice")
else:
    print("Borys")

Solution (Python):
n,a,b = map(int,input().split())

if (b - a) % 2 == 0:
    print("Alice")
else:
    print("Borys")

Solution (Python):
N, A, B = map(int, input().split())
t_a = True
t_b = False
while True:
    if t_a:
        if A - 1 == B or A - B <= -1:
            A += 1
        elif A + 1 == B or A - B >= 1:
            A -= 1

        if A == B or A < 0 or A > N:
            print("Borys")
            break
        t_a = False
        t_b = True
    elif t_b:
        if B - 1 == B or B - A <= -1:
            B += 1
        elif B + 1 == B or B - A >= 1:
            B -= 1

        if A == B or B < 0 or B > N:
            print("Alice")
            break
        t_a = True
        t_b = False

Solution (Python):
N, A, B = map(int, input().split())
t_a = True
t_b = False
while True:
    if t_a:
        if A - B > 0:
            if A - 1 == B:
                A += 1
            else:
                A -= 1
        elif A - B < 0:
            if A + 1 == B:
                A -= 1
            else:
                A += 1

        if A == B or A < 0 or A > N:
            print("Borys")
            break
        t_a = False
        t_b = True
    elif t_b:
        if B - A > 0:
            if B - 1 == B:
                B += 1
            else:
                B -= 1
        elif B - A < 0:
            if B + 1 == B:
                B -= 1
            else:
                B += 1

        if A == B or B < 0 or B > N:
            print("Alice")
            break
        t_a = True
        t_b = False

Solution (Python):
n,a,b=input().split()
if (int(b) - int(a)) % 2 == 0:
    print("Alice")
else:
    print("Borys")

Solution (Python):
def main(n, a, b):
    if (a - b) % 2 == 0:
        print('Alice')
    else:
        print('Borys')


if __name__ == "__main__":
    n, a, b = map(int, input().split())

    main(n, a, b)

Solution (Python):
N, A, B = list(map(int,input().split()))

space = abs(B - A )

if space % 2 ==0:
    print("Alice")
else :
    print("Borys")

Solution (Python):
N, A, B = map(int,input().split())
gap = abs(A-B)-1
if gap%2!=0:
    print('Alice')
else:
    print('Borys')

Solution (Python):
n, a, b = [int(i) for i in input().split(' ')]
print('Alice' if abs(a-b) % 2 == 0 else 'Borys')

Solution (Python):

N, A, B = map(int, input().split(" "))

print(['Alice','Borys'][(B-A)%2])

Solution (Python):

N, A, B = map(int, input().split(" "))

if (B-A)%2 == 0:
    print('Alice')
else:
    print('Borys')

Solution (Python):
from sys import stdin

n,a,b = [int(x) for x in stdin.readline().rstrip().split()]

if (b-a)%2 == 1:
    print("Borys")
else:
    print("Alice")

Solution (Python):
from sys import stdin

n,a,b = [int(x) for x in stdin.readline().rstrip().split()]

while True:
    if a+1 != b:
        a += 1
    else:
        print("Borys")
        exit()
    if b-1 != a:
        b -= 1
    else:
        print("Alice")
        exit()

Solution (Python):
N,A,B=map(int,input().split())

if(abs(A-B)%2==0):
    print("Alice")
else:
    print("Borys")

Solution (Python):
N,A,B = map(int,input().split())
if (B-A-1)%2==1:
    print("Alice")
else:
    print("Borys")

Solution (Python):
N,A,B = map(int,input().split())

if abs(A - B) % 2 == 0:
  ans = 'Alice'
else:
  ans = 'Borys'

print(ans)

Solution (Python):
n, a, b = map(int, input().split())

if abs(b - a) % 2 == 0:
    print("Alice")
elif abs(b - a) % 2 == 1:
    print("Borys")

Solution (Python):
n, a, b  = map(int, input().split())

for _ in range(n):
    if a < b:
        a += 1
        if a == b:
            print('Borys')
            exit()

    if b <= n:
        b += 1
    else:
        b -= 1
        if b == a:
            print('Alice')
            exit()
else:
    print('Draw')

Solution (Python):
N, A, B = map(int, input().split())
if (A - B) % 2 == 0:
    print('Alice')
else:
    print('Borys')

Solution (Python):
N,A,B = map(int,input().split())
if (B-A) % 2 == 0:
    print('Alice')
else:
    print('Borys')

Solution (Python):
n,a,b=map(int,input().split())
if (b-a)%2==1:
  print('Borys')
else:
  print('Alice')

Solution (Python):
n,a,b = map(int, input().split())
if abs(a-b)%2 == 0:
	print("Alice")
else:
	print("Borys")

Solution (Python):
N,A,B = map(int,input().split())
while N == N:
  if A + 1 != B:
    A += 1
  else:
    print("Borys")
    exit()
  if B - 1 != A:
    B -= 1
  else:
    print("Alice")
    exit()

Solution (Python):
N, A, B = map(int, input().split())
print("Borys" if A+B&1 else "Alice")

Solution (Python):
n,a,b=map(int,input().split())

if (b-(a+1))%2==0:
    print("Borys")
else:
    print("Alice")

Solution (Python):

from collections import defaultdict,deque
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import sys, random, itertools, math
sys.setrecursionlimit(10**5)
input = sys.stdin.readline
sqrt = math.sqrt
def LI(): return list(map(int, input().split()))
def LF(): return list(map(float, input().split()))
def LI_(): return list(map(lambda x: int(x)-1, input().split()))
def II(): return int(input())
def IF(): return float(input())
def LS(): return list(map(list, input().split()))
def S(): return list(input().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 = 1e10


def solve():
    n, a, b = LI()
    print("Borys" if (b - a) & 1 else "Alice")
    return



if __name__ == '__main__':
    solve()

Solution (Python):
n,a,b=map(int,input().split())
if (b-a)%2==0:
  print('Alice')
else:
  print('Borys')

Solution (Python):

N, A, B = map(int, input().split())
if (B - A) % 2 == 0:
    print("Alice")
else:
    print("Borys")

Solution (Python):
N,A,B = map(int,input().split())
if (B-A)%2==0:
    print("Alice")
else:
    print("Borys")

Solution (Python):
N,A,B=map(int,input().split())
while True:
    if A+1<B:
        A+=1
    elif 1<A:
        A-=1
    else:
        print("Borys")
        break
    if A<B-1:
        B-=1
    elif B<N:
        B+=1
    else:
        print("Alice")
        break

Solution (Python):


N,a,b=map(int,input().split())
M=N/2
while True:
    
    
    if a+1<b:
        a+=1
    elif a+1==b:
        a-=1
        
    if a<=0:
        print('Borys')
        break
    
    if a+1<b:
        b-=1
    elif a+1==b:
        b+=1
        
    if b>N:
        print('Alice')
        break

Solution (Python):
a,b,c = map(int,input().split())
if abs(c-b)%2 == 0:
  print("Alice")
else:
  print("Borys")

Solution (Python):
N,A,B=map(int,input().split())

if (B-A-1)%2==1:
    print('Alice')
else:
    print('Borys')

Solution (Python):
n,a,b=map(int,input().split())
if n==2:
    print('Borys')
else:
    if (b-a)%2==0:
        print('Alice')
    elif n%2==0 and (b-a)%2==0:
        print('Draw')
    else:
        print('Borys')

Solution (Python):
import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda:sys.stdin.readline().rstrip()
def resolve():
    n,a,b=map(int,input().split())
    print("Alice" if((a+b)&1==0) else "Borys")
resolve()

Solution (Python):
N, A, B = map(int, input().split())
if A % 2 == B % 2:
  print('Alice')
else:
  print('Borys')

Solution (Python):
import sys
n, a, b = [int(i) for i in sys.stdin.readline().split()]
if (b - a - 1) % 2 == 1:
    print("Alice")
else:
    print("Borys")

Solution (Python):
N, A, B = [int(_) for _ in input().split()]

if (B - A) % 2 == 1:
    print("Borys")
else:
    print("Alice")

Solution (Python):
n, a, b = map(int, input().split())

if abs(a-b) % 2 == 0:
    print("Alice")
else:
    print("Borys")

Solution (Python):
a,b,c=map(int,input().split())
if (c-b)%2:
  print("Borys")
else:
  print("Alice")

Solution (Python):
N,A,B = map(int, input().split())

if (abs(A - B)-1) % 2 != 0:
    print('Alice')
else:
    print('Borys')

Solution (Python):
N, A, B = map(int, input().split())

if A % 2 == B % 2 :
  print('Alice')
else :
  print('Borys')

Solution (Python):
a = input().split()
if (int(a[2]) - int(a[1])) % 2 == 0:
    print('Alice')
else:
    print('Borys')

Solution (Python):

def main()->None:
    N, A, B = map(int, input().split())
    diff = B - A - 1 
    if diff % 2 == 0:
        print("Borys")

    else:
        print("Alice")


if __name__ == "__main__":
    main()

Solution (Python):
n,a,b=map(int,input().split())
if (b-a)%2==1:
  print("Borys")
else:
  print("Alice")

Solution (Python):
N, A, B = map(int, input().split())
if (A % 2 == 0) ^ (B % 2 == 0): 
        print("Borys")
else:
        print("Alice")

Solution (Python):
n,a,b=map(int,input().split())
print('Alice' if (b-a)%2==0 else 'Borys')

Solution (Python):
def examA():
    N, A, B = LI()
    if (A-B)%2==0:
        ans = "Alice"
    else:
        ans = "Borys"
    print(ans)
    return

import sys,copy,bisect,itertools,heapq,math
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
mod = 10**9 + 7
inf = float('inf')

if __name__ == '__main__':
    examA()

Solution (Python):

import sys
sys.setrecursionlimit(10000000)
INF = 1<<32


def solve(N: int, A: int, B: int):
    if (B-A)%2 != 1:
        print('Alice')
    else:
        print('Borys')
        
    return



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  
    A = int(next(tokens))  
    B = int(next(tokens))  
    solve(N, A, B)

if __name__ == '__main__':
    main()

Solution (Python):
N, A, B = map(int, input().split())
if (B-A)%2:
    print("Borys")
else:
    print("Alice")

Solution (Python):
n, a, b = map(int, input().split())
if abs(a-b)%2 == 0:
  print('Alice')
else:
  print('Borys')

Solution (Python):
n, a, b = map(int, input().split())
if abs(a-b)%2 == 0:
  print('Alice')
else:
  print('Borys')

Solution (Python):
n,a,b = map(int,input().split())

d = b - a

print('Borys' if d%2==1 else 'Alice')

Solution (Python):

n, a, b = map(int, input().split())

if (b-a) % 2 == 0:
  print('Alice')
else:
  print('Borys')

Solution (Python):
n,a,b = map(int, input().split())
print("Alice" if (a-b+1)%2 else "Borys")

Solution (Python):
n, a, b = map(int, input().split())

if (a-b) % 2 == 1:
    print('Borys')
else:
    print('Alice')

Solution (Python):
n, a, b = map(int, input().split())
print ("Alice" if abs(a-b) % 2 == 0 else "Borys")

Solution (Python):
n,a,b=map(int,input().split())
if((b-a)%2==1):
  print("Borys")
else:
  print("Alice")

Solution (Python):
import sys


def solve():
    readline = sys.stdin.buffer.readline
    mod = 10 ** 9 + 7
    n, a, b = list(map(int, readline().split()))
    if (abs(a - b) - 1) % 2 != 0:
        print("Alice")
    else:
        print("Borys")


if __name__ == '__main__':
    solve()

Solution (Python):
x,a,b=map(int,input().split())
print('Alice' if (b-a)%2==0 else 'Borys')

Solution (Python):
n,a,b=map(int,input().split())
if abs(a-b)%2==1:
  print("Borys")
else:
  print("Alice")

Solution (Python):
n, a, b = map(int, input().split())
if (b-a)%2:
  print("Borys")
else:
  print("Alice")

Solution (Python):
N,A,B = map(int,input().split())

if (B-A)%2==0:
    print('Alice')
else:
    print('Borys')

Solution (Python):
N,A,B=map(int,input().split())
print(("Borys","Alice")[(abs(A-B)-1)%2==1])

Solution (Python):
N, A, B = map(int, input().split())
if (A-B) % 2 == 0:
    print("Alice")
else:
    print("Borys")

Solution (Python):
n,a,b = map(int,input().split())
print('Alice' if abs(b-a)%2==0 else 'Borys')

Solution (Python):
import bisect
import heapq
import itertools
import math
import operator
import os
import re
import string
import sys
from collections import Counter, deque, defaultdict
from copy import deepcopy
from decimal import Decimal
from fractions import gcd
from functools import lru_cache, reduce
from operator import itemgetter, mul, add, xor

import numpy as np

if os.getenv("LOCAL"):
    sys.stdin = open("_in.txt", "r")

sys.setrecursionlimit(10 ** 9)
INF = float("inf")
IINF = 10 ** 18
MOD = 10 ** 9 + 7



N, A, B = list(map(int, sys.stdin.buffer.readline().split()))

a = abs(A - B)
if a  % 2== 1:
    print('Borys')
else:
    print('Alice')

Solution (Python):
n, a, b = map(int, input().split())
if (a-b)%2 == 0 :
    print("Alice")
else:
    print("Borys")

Solution (Python):
n,a,b = map(int,input().split())
ab = b-a
if ab % 2 == 0:
    print("Alice")
else:
    print("Borys")

Solution (Python):
n, a, b = [int(x) for x in input().split()]

dist = b-a
if dist % 2:
    print("Borys")
else:
    print("Alice")

Solution (Python):
import sys

input = sys.stdin.readline

ri = lambda: int(input())
rs = lambda: input().rstrip()
ril = lambda: list(map(int, input().split()))
rsl = lambda: input().rstrip().split()
ris = lambda n: [ri() for _ in range(n)]
rss = lambda n: [rs() for _ in range(n)]
rils = lambda n: [ril() for _ in range(n)]
rsls = lambda n: [rsl() for _ in range(n)]

n, a, b = ril()
if (b - a) % 2 == 0:
    print('Alice')
else:
    print('Borys')

Solution (Python):
n,a,b=map(int,input().split())
if n==2:
    print('Borys')
else:
    if (b-a)%2==0:
        print('Alice')
    elif n%2==0 and (b-a)%2==0:
        print('Draw')
    else:
        print('Borys')

Solution (Python):

N, A, B = map(int, input().split())
if (B - A - 1) % 2 == 1:
    print("Alice") 
else:
    print("Borys")

Solution (Python):
n, a, b = map(int, input().split())

if (b - a) % 2 == 0:
    print("Alice")
else:
    print("Borys")

Solution (Python):
import sys


def solve():
    readline = sys.stdin.buffer.readline
    mod = 10 ** 9 + 7
    n, a, b = list(map(int, readline().split()))
    print("Alice" if abs(a - b) % 2 == 0 else "Borys")


if __name__ == '__main__':
    solve()

Solution (Python):


N, A, B = list(map(int, input().split()))
a_idx = A
b_idx = B
turn = "A"
while True:
    
    if turn == "A":
        if a_idx == 1 and b_idx == a_idx + 1:
            winner = "Borys"
            break
    else:
        if b_idx == N and a_idx == b_idx - 1:
            winner = "Alice"
            break

    if turn == "A":
        if b_idx == a_idx + 1:
            a_idx -= 1
        else:
            a_idx += 1
        turn = "B"
    else:
        if a_idx == b_idx - 1:
            b_idx += 1
        else:
            b_idx -= 1
        turn = "A"

ans = winner
print(ans)

Solution (Python):
n,a,b = map(int,input().split())

check = b-a

if check%2 != 0:
    print("Borys")
else:
    print("Alice")

Solution (Python):
n, a, b = map(int, input().split())
diff = b - a - 1
if diff%2:
    print("Alice")
elif diff%2 == 0:
    print("Borys")
else:
    print("Draw")

Solution (Python):
N,A,B=map(int,input().split())
count=1
while B-A!=1:
  if count%2==1:
    A+=1
  else:
    B-=1
  count+=1
if count%2==1:
  print('Borys')
else:
  print('Alice')

Solution (Python):
def main():
    n, a, b = map(int, input().split())

    if (b - a) % 2:
        ans = "Borys"
    else:
        ans = "Alice"

    print(ans)


if __name__ == "__main__":
    main()

Solution (Python):
n, a, b = map(int, input().rstrip("\n").split())

print("Borys" if (b - a) % 2 else "Alice")

Solution (Python):
n, a, b = map(int, input().split())

if (b - a - 1) % 2 == 1:
    print('Alice')
else:
    print('Borys')

Solution (Python):

N,A,B = map(int,input().split())

if (B - A) % 2 == 1:
    print ("Borys")

else:
    print ("Alice")

Solution (Python):
N, A, B = map(int, input().split())
diff = A - B
if diff % 2 == 0:
    print("Alice")
else:
    print("Borys")

Solution (Python):
n,a,b=map(lambda x: int(x), input().split())
if (a-b)%2==0:
    print('Alice')
else:
    print('Borys')

Solution (Python):
n,a,b=map(int,input().split())
if (a-b)%2:
  print("Borys")
else:
  print("Alice")

Solution (Python):
import sys


def slove():
    input = sys.stdin.readline
    mod = 10 ** 9 + 7
    n, a, b = list(map(int, input().rstrip('\n').split()))
    if (a - b) % 2 == 0:
        print("Alice")
    else:
        print("Borys")


if __name__ == '__main__':
    slove()

Solution (Python):
n, a, b = map(int, input().split())

if (b-a) % 2 == 0:
    print('Alice')
else:
    print('Borys')

Solution (Python):
def main():
    n, a, b = map(int, input().split())
    temp = b - a
    if temp % 2 == 0:
        print('Alice')
    else:
        print('Borys')


if __name__ == '__main__':
    main()

Solution (Python):
N,A,B = map(int,input().split())

if (A + B) % 2 == 0:
    print("Alice")
else:
    print("Borys")

Solution (Python):
N,A,B=map(int,input().split())

if (B-A)%2==0:
    print("Alice")
else:
    print("Borys")

Solution (Python):
n,a,b = [int(i) for i in input().split()]

if (a+b)%2 == 0:
  print('Alice')
else:
  print('Borys')

Solution (Python):
n, a, b = map(int,input().split())
if (b-a) % 2 == 0:
    print("Alice")
else:
    print("Borys")

Solution (Python):
N,A,B=map(int,input().split())
print('Alice' if (B-A)%2==0 else 'Borys')

Solution (Python):
N, A, B = map(int, input().split())

if (A - B) % 2 == 0:
    print('Alice')
else:
    print('Borys')

Solution (Python):
n , a , b = map(int,input().split())
m = b - a

if m % 2 == 0:
    print("Alice")
else:
    print("Borys")

Solution (Python):
n,a,b = map(int,input().split())	
ans=[ "Alice", "Borys", "Draw"]
if (b-a) %2 ==0:
    print(ans[0])
else:
    print(ans[1])

Solution (Python):
N,A,B=map(int,input().split())
C=B-A-1
if C%2!=0:
  print("Alice")
else:
  print("Borys")

Solution (Python):
n, a, b = map(int, input().split())
print("Alice" if (b-a-1) % 2 == 1 else "Borys")

Solution (Python):
N, A, B = map(int, input().split())
print("Alice" if (B - A) % 2 == 0 else "Borys")

Solution (Python):
N, A, B = map(int, input().split())


if (B - A) % 2 == 0:
  print('Alice')
else:
  print('Borys')

Solution (Python):
N, A, B = tuple(map(int, input().split()))
i = 0
while True:
    if i % 2 == 0:
        if A + 1 != B:
            A += 1
        else:
            A -= 1
    else:
        if B - 1 != A:
            B -= 1
        else:
            B += 1
    if A < 1:
        print("Borys")
        break
    if B > N:
        print("Alice")
        break
    i += 1

Solution (Python):
_,A,B=map(int,input().split());print("ABloircyes"[(B-A)%2::2])

Solution (Python):
N,A,B=map(int,input().split())

if (B-A)%2==1:
  print("Borys")
else:
  print("Alice")

Solution (Python):
N, A, B = map(int, input().split())

if abs(A - B - 1) % 2 == 0:
    print('Borys')
else:
    print('Alice')

Solution (Python):
n, a, b = map(int, input().split())

if (a + b) % 2 == 0:
    print('Alice')
else:
    print('Borys')

Solution (Python):
n, a, b = map(int, input().split())

print("Alice" if (a-b)%2 == 0 else "Borys")

Solution (Python):
N,A,B=map(int,input().split())
if(B-A-1)%2 ==1:
  print('Alice')
else:
  print('Borys')

Solution (Python):
N,A,B=map(int,input().split())
print('Alice' if (B-A-1)%2 else 'Borys')

Solution (Python):
def solve(n, a, b):
    for t in range(n*2):
        if t % 2 == 0:
            if a < b + 1:
                a += 1
            elif a == b + 1:
                a += 1
            elif a == b - 1:
                a -= 1
            elif a > b - 1:
                a -= 1
            else:
                return "Borys"
        else:
            if b < a + 1:
                b += 1
            elif b == a + 1:
                b += 1
            elif b == a - 1:
                b -= 1
            elif b > a - 1:
                b -= 1
            else:
                return "Alice"
        if a == b:
            return "Borys" if t % 2 == 0 else "Alice"
        if (a <= 0) or (n < a):
            return "Borys"
        elif (b <= 0) or (n < b):
            return "Alice"
    return "Draw"

n, a, b = map(int, input().split())
print(solve(n, a, b))

Solution (Python):
N, A, B = map(int, input().split())
if (B - A) % 2 == 0:
  print("Alice")
else:
  print("Borys")

Solution (Python):
N,A,B = map(int, input().split())

if (B-A)%2==0:
  ans = 'Alice'
else:
  ans = 'Borys'
  
print(ans)

Solution (Python):
import sys
input = sys.stdin.readline

def main():
    N, A, B = map(int, input().split())
    tmp = B-A-1

    if not tmp&1:
        print("Borys")
    else:
        print("Alice")


if __name__ == "__main__":
    main()

Solution (Python):
n,a,b = map(int, input().split())

if (b - a) % 2 is 1:
  print('Borys')
else:
  print('Alice')

Solution (Python):
N, A, B = map(int, input().split())
if (B-A)%2 == 0:
  print("Alice")
else:
  print("Borys")

Solution (Python):
N,A,B = (int(x) for x in input().split())

if (B-A)%2==0:
    print("Alice")
else:
    print("Borys")

Solution (Python):
N, A, B = map(int, input().split())
print('Alice' if (B - A) % 2 == 0 else 'Borys')

Solution (Python):
import sys

input = sys.stdin.readline


class AtCoder:
    def main(self):
        N, A, B = map(int, input().split())
        if abs(A - B) % 2 == 1:
            print('Borys')
        else:
            print('Alice')



if __name__ == '__main__':
    AtCoder().main()

Solution (Python):
n,a,b=map(int,input().split())
if abs(a-b)%2 ==1:
    print('Borys')
else:
    print('Alice')

Solution (Python):
def main():
    n, a, b = map(int, input().split())
    if (b - a) % 2 == 0:
        print("Alice")
    else:
        print("Borys")

if __name__ == '__main__':
    main()

Solution (Python):
def main():
    n, a, b = map(int, input().split())
    if b - a == 1:
        print("Borys")
    elif (b - a) % 2 == 0:
        print("Alice")
    else:
        print("Borys")
    
    


if __name__ == '__main__':
    main()

Solution (Python):
N, A, B = map(int, input().split())
if (B - A) % 2 == 0:
  print('Alice')
else:
  print('Borys')

Solution (Python):
if __name__ == "__main__":
    N, A, B = map(int, input().split())
    
    if (B - 1 - A) % 2 == 0:
        print("Borys")
    else:
        print("Alice")

Solution (Python):
def main():
    N,A,B = map(int,input().split())
    if (B-A)%2 == 0:
        print("Alice")
    else:
        print("Borys")

if __name__ == "__main__":
    main()

Solution (Python):
N, A, B = map(int, input().split())
print('Alice' if (abs(A - B) - 1) % 2 == 1 else 'Borys')

Solution (Python):

from collections import defaultdict,deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
    return [I() for i in range(n)]
def LIR(n):
    return [LI() for i in range(n)]
def SR(n):
    return [S() for i in range(n)]
def LSR(n):
    return [LS() for i in range(n)]

sys.setrecursionlimit(1000000)
mod = 1000000007


def A():
    n,a,b = LI()
    if (b-a)%2:
        print("Borys")
    else:
        print("Alice")
    return


def B():
    def f(m):
        if d[m] != None:
            return d[m]
        n = m
        for i in a:
            n = n-n%i
        d[m] = n
        return n
    k = I()
    a = LI()
    d = defaultdict(lambda : None)
    l,r = 0,int(1e18)
    while r-l > 1:
        m = (r+l)//2
        if f(m) < 2:
            l = m
        else:
            r = m
    mi = r
    l,r = 0,int(1e18)
    while r-l > 1:
        m = (r+l)//2
        if f(m) <= 2:
            l = m
        else:
            r = m
    ma = l
    if mi <= ma:
        if f(mi) != 2:
            print(-1)
        else:
            print(mi,ma)
    else:
        print(-1)
    return


def C():
    n = I()

    return


def D():
    n = I()

    return


def E():
    n = I()

    return


def F():
    n = I()

    return



if __name__ == "__main__":
    A()

Solution (Python):
n,a,b=map(int,input().split())

if (a-b) % 2 == 0:
  print("Alice")
else:
  print("Borys")

Solution (Python):

n, a, b = [int(el) for el in input().split(' ')]

while 1 <= a <= n and 1 <= b <= n:
    if b != a + 1 and 1 <= a +1 <= n:
        a = a + 1
    elif b != a - 1 and 1 <= a - 1 <= n:
        a = a - 1
    else:
        print('Borys')
        break
    if a != b - 1 and 1 <= b - 1 <= n:
        b = b - 1
    elif a != b + 1 and 1 <= b + 1 <= n:
        b = b + 1
    else:
        print('Alice')
        break

Solution (Python):
n, a, b = map(int, input().split())

if n == b and abs(a - b) == 1:
    print('Borys')
elif abs(a - b) % 2 == 0:
    print('Alice')
elif abs(a - b) % 2 != 0:
    print('Borys')
else:
    print('Draw')

Solution (Python):
def main():
    N, A, B = map(int, input().split())
    if (B-A-1) % 2 == 1:
        return "Alice"
    else:
        return "Borys"

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

Solution (Python):


import sys



tmp = input().split()
n,a,b = list(map(lambda a: int(a), tmp))

if((b-a)%2==0):
	print("Alice")
else:
	print("Borys")

Solution (Python):
N,A,B = map(int,input().split())
if (B - A) % 2 == 0:
  print("Alice")
else:
  print("Borys")

Solution (Python):
n,a,b=map(int,input().split())
if (b-a)%2==0:
    print("Alice")
else:
    print("Borys")

Solution (Python):
N, A, B = map(int, input().split())
if (A-B)%2 == 1:
  print("Borys")
else:
  print("Alice")

Solution (Python):
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time

sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7

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

def main():
  n,a,b=LI()

  if (b-a)%2==0:
    return 'Alice'
  else:
    return 'Borys'

print(main())

Solution (Python):
N, A, B = map(int,input().split())

if (A-B) % 2 == 0:
    print("Alice")
else:
    print("Borys")

Solution (Python):
N,A,B=map(int,input().split())
print('Borys' if (B-A-1)%2 == 0 else 'Alice')

Solution (Python):
def main():
    n, a, b = [int(i) for i in input().split()]
    print('Alice' if (max(a,b)-min(a,b)-1)%2 == 1 else 'Borys')


if __name__ == '__main__':
    main()

Solution (Python):



import sys
import math
import bisect
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()))

n,a,b = LI()
if (b-a) % 2:
    print('Borys')
else:
    print('Alice')

Solution (Python):

import sys, math, fractions, itertools, collections, copy, heapq


def solve(N: int, A: int, B: int):
    if (B-A) % 2 == 0:
        print('Alice')
    else:
        print('Borys')
    return



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  
    A = int(next(tokens))  
    B = int(next(tokens))  
    solve(N, A, B)

if __name__ == '__main__':
    main()

Solution (Python):
import sys
nums, alice, borys = map(int,input().split())
if nums == 2:
    print("Borys")
    sys.exit()

if alice > borys:
    space = alice - borys-1
else:
    space = borys - alice-1

if space % 2 == 0:
    print("Borys")
elif space % 2 == 1:
    print("Alice")