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 queue
  from collections import defaultdict
  
  
  def readInt():
      return int(input())
  
  
  def readInts():
      return list(map(int, input().split()))
  
  
  def readChar():
      return input()
  
  
  def readChars():
      return input().split()
  
  
  def factorization(n):
      res = []
      if n % 2 == 0:
          res.append(2)
      for i in range(3, math.floor(n // 2) + 1, 2):
          if n % i == 0:
              c = 0
              for j in res:
                  if i % j == 0:
                      c = 1
              if c == 0:
                  res.append(i)
      return res
  
  
  def fact2(n):
      p = factorization(n)
      res = []
      for i in p:
          c = 0
          z = n
          while 1:
              if z % i == 0:
                  c += 1
                  z /= i
              else:
                  break
          res.append([i, c])
      return res
  
  
  def fact(n):  # 階乗
      ans = 1
      m = n
      for _i in range(n - 1):
          ans *= m
          m -= 1
      return ans
  
  
  def comb(n, r):  # コンビネーション
      if n < r:
          return 0
      l = min(r, n - r)
      m = n
      u = 1
      for _i in range(l):
          u *= m
          m -= 1
      return u // fact(l)
  
  
  def printQueue(q):
      r = qb
      ans = [0] * r.qsize()
      for i in range(r.qsize() - 1, -1, -1):
          ans[i] = r.get()
      print(ans)
  
  
  def dq():
      return queue.deque()
  
  
  class UnionFind:
      def __init__(self, n):
          self.n = n
          self.parents = [-1] * n
  
      def find(self, x):  # root
          if self.parents[x] < 0:
              return x
          else:
              self.parents[x] = self.find(self.parents[x])
              return self.parents[x]
  
      def union(self, x, y):
          x = self.find(x)
          y = self.find(y)
  
          if x == y:
              return
  
          if self.parents[x] > self.parents[y]:
              x, y = y, x
  
          self.parents[x] += self.parents[y]
          self.parents[y] = x
  
      def size(self, x):
          return -1 * self.parents[self.find(x)]
  
      def same(self, x, y):
          return self.find(x) == self.find(y)
  
      def members(self, x):  # much time
          root = self.find(x)
          return [i for i in range(self.n) if self.find(i) == root]
  
      def roots(self):
          return [i for i, x in enumerate(self.parents) if x < 0]
  
      def group_count(self):
          return len(self.roots())
  
      def all_group_members(self):
          return {r: self.members(r) for r in self.roots()}  # 1~n
  
  
  def bitArr(n):  # ビット全探索
      x = 1
      zero = "0" * n
      ans = []
      ans.append([0] * n)
      for i in range(2**n - 1):
          ans.append(list(map(lambda x: int(x), list((zero + bin(x)[2:])[-1 * n :]))))
          x += 1
      return ans
  
  
  def arrsSum(a1, a2):
      for i in range(len(a1)):
          a1[i] += a2[i]
      return a1
  
  
  def maxValue(a, b, v):
      v2 = v
      for i in range(v2, -1, -1):
          for j in range(v2 // a + 1):  # j:aの個数
              k = i - a * j
              if k % b == 0:
                  return i
      return -1
  
  
  n, a, b = readInts()
  
  if b - a - 1 % 2 == 1:
      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"}]