output_description: Print `Left` if the balance scale tips to the left; print `Balanced` if it
  balances; print `Right` if it tips to the right.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      A B C D
attempt: ###==================================================
  ### import
  # import bisect
  # from collections import Counter, deque, defaultdict
  # from copy import deepcopy
  # from functools import reduce, lru_cache
  # from heapq import heappush, heappop
  # import itertools
  # import math
  # import string
  import sys
  
  
  ### stdin
  def input():
      return sys.stdin.readline().rstrip()
  
  
  def iIn():
      return int(input())
  
  
  def iInM():
      return map(int, input().split())
  
  
  def iInM1():
      return map(int1, input().split())
  
  
  def iInLH():
      return list(map(int, input().split()))
  
  
  def iInLH1():
      return list(map(int1, input().split()))
  
  
  def iInLV(n):
      return [iIn() for _ in range(n)]
  
  
  def iInLV1(n):
      return [iIn() - 1 for _ in range(n)]
  
  
  def iInLD(n):
      return [iInLH() for _ in range(n)]
  
  
  def iInLD1(n):
      return [iInLH1() for _ in range(n)]
  
  
  def sInLH():
      return list(input().split())
  
  
  def sInLV(n):
      return [input().rstrip("\n") for _ in range(n)]
  
  
  def sInLD(n):
      return [sInLH() for _ in range(n)]
  
  
  ### stdout
  def OutH(lst, deli=" "):
      print(deli.join(map(str, lst)))
  
  
  def OutV(lst):
      print("\n".join(map(str, lst)))
  
  
  ### setting
  sys.setrecursionlimit(10**6)
  ### utils
  int1 = lambda x: int(x) - 1
  ### constants
  INF = int(1e9)
  MOD = 1000000007
  dx = (-1, 0, 1, 0)
  dy = (0, -1, 0, 1)
  ###---------------------------------------------------
  
  A, B, C, D = iInM()
  
  if A + B > C + D:
      print("Left")
  elif A + B == C + D:
      print("Balanced")
  else:
      print("Right")
  
problem_description: Statement
  
  A balance scale tips to the left if L>R, where L is the total weight of the
  masses on the left pan and R is the total weight of the masses on the right
  pan. Similarly, it balances if L=R, and tips to the right if L<R.
  
  Takahashi placed a mass of weight A and a mass of weight B on the left pan of
  a balance scale, and placed a mass of weight C and a mass of weight D on the
  right pan.
  
  Print `Left` if the balance scale tips to the left; print `Balanced` if it
  balances; print `Right` if it tips to the right.
samples: [{"input": "3 8 7 1", "output": "Left\n    \n\nThe total weight of the masses on the left pan is 11, and the total weight of\nthe masses on the right pan is 8. Since 11>8, we should print `Left`.\n\n* * *"}, {"input": "3 4 5 2", "output": "Balanced\n    \n\nThe total weight of the masses on the left pan is 7, and the total weight of\nthe masses on the right pan is 7. Since 7=7, we should print `Balanced`.\n\n* * *"}, {"input": "1 7 6 4", "output": "Right\n    \n\nThe total weight of the masses on the left pan is 8, and the total weight of\nthe masses on the right pan is 10. Since 8<10, we should print `Right`."}]