output_description: Print `Alice` if Alice wins, `Borys` if Borys wins, and `Draw` if nobody wins.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N A B
attempt: import math
  import fractions
  import bisect
  import collections
  import itertools
  import heapq
  import string
  import sys
  import copy
  from decimal import *
  from collections import deque
  
  sys.setrecursionlimit(10**7)
  MOD = 10**9 + 7
  INF = float("inf")  # 無限大
  
  
  def gcd(a, b):
      return fractions.gcd(a, b)  # 最大公約数
  
  
  def lcm(a, b):
      return (a * b) // fractions.gcd(a, b)  # 最小公倍数
  
  
  def iin():
      return int(sys.stdin.readline())  # 整数読み込み
  
  
  def ifn():
      return float(sys.stdin.readline())  # 浮動小数点読み込み
  
  
  def isn():
      return sys.stdin.readline().split()  # 文字列読み込み
  
  
  def imn():
      return map(int, sys.stdin.readline().split())  # 整数map取得
  
  
  def imnn():
      return map(lambda x: int(x) - 1, sys.stdin.readline().split())  # 整数-1map取得
  
  
  def fmn():
      return map(float, sys.stdin.readline().split())  # 浮動小数点map取得
  
  
  def iln():
      return list(map(int, sys.stdin.readline().split()))  # 整数リスト取得
  
  
  def iln_s():
      return sorted(iln())  # 昇順の整数リスト取得
  
  
  def iln_r():
      return sorted(iln(), reverse=True)  # 降順の整数リスト取得
  
  
  def fln():
      return list(map(float, sys.stdin.readline().split()))  # 浮動小数点リスト取得
  
  
  def join(l, s=""):
      return s.join(l)  # リストを文字列に変換
  
  
  def perm(l, n):
      return itertools.permutations(l, n)  # 順列取得
  
  
  def perm_count(n, r):
      return math.factorial(n) // math.factorial(n - r)  # 順列の総数
  
  
  def comb(l, n):
      return itertools.combinations(l, n)  # 組み合わせ取得
  
  
  def comb_count(n, r):
      return math.factorial(n) // (
          math.factorial(n - r) * math.factorial(r)
      )  # 組み合わせの総数
  
  
  def two_distance(a, b, c, d):
      return ((c - a) ** 2 + (d - b) ** 2) ** 0.5  # 2点間の距離
  
  
  def m_add(a, b):
      return (a + b) % MOD
  
  
  def print_list(l):
      print(*l, sep="\n")
  
  
  def sieves_of_e(n):
      is_prime = [True] * (n + 1)
      is_prime[0] = False
      is_prime[1] = False
      for i in range(2, int(n**0.5) + 1):
          if not is_prime[i]:
              continue
          for j in range(i * 2, n + 1, i):
              is_prime[j] = False
      return is_prime
  
  
  N, A, B = imn()
  
  if (B - A) % 2 == 0:
      print("Alice")
  else:
      print("Borys")
  
problem_description: 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?
samples: [{"input": "5 2 4", "output": "Alice\n    \n\nAlice can move her token to cell 3. After that, Borys will be unable to move\nhis token to cell 3, so he will have to move his token to cell 5. Then, Alice\nmoves her token to cell 4. Borys can't make a move and loses.\n\n* * *"}, {"input": "2 1 2", "output": "Borys\n    \n\nAlice can't make the very first move and loses.\n\n* * *"}, {"input": "58 23 42", "output": "Borys"}]