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: # -*- coding: utf-8 -*-
  
  #############
  # Libraries #
  #############
  
  import sys
  input = sys.stdin.readline
  
  import math
  from collections import deque
  from fractions import gcd
  from functools import lru_cache
  
  
  #############
  # Constants #
  #############
  
  MOD = 10**9+7
  INF = float('inf')
  
  #############
  # Functions #
  #############
  
  ######INPUT######
  def inputI(): return int(input().strip())
  def inputS(): return input().strip()
  def inputIL(): return list(map(int,input().split()))
  def inputSL(): return list(map(str,input().split()))
  def inputILs(n): return list(int(input()) for _ in range(n))
  def inputSLs(n): return list(input().strip() for _ in range(n))
  def inputILL(n): return [list(map(int, input().split())) for _ in range(n)]
  def inputSLL(n): return [list(map(str, input().split())) for _ in range(n)]
  
  #####Inverse#####
  def inv(n): return pow(n, MOD-2, MOD)
  
  ######Combination######
  kaijo_memo = []
  def kaijo(n):
    if(len(kaijo_memo) > n):
      return kaijo_memo[n]
    if(len(kaijo_memo) == 0):
      kaijo_memo.append(1)
    while(len(kaijo_memo) <= n):
      kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
    return kaijo_memo[n]
  
  gyaku_kaijo_memo = []
  def gyaku_kaijo(n):
    if(len(gyaku_kaijo_memo) > n):
      return gyaku_kaijo_memo[n]
    if(len(gyaku_kaijo_memo) == 0):
      gyaku_kaijo_memo.append(1)
    while(len(gyaku_kaijo_memo) <= n):
      gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
    return gyaku_kaijo_memo[n]
  
  def nCr(n,r):
    if(n == r):
      return 1
    if(n < r or r < 0):
      return 0
    ret = 1
    ret = ret * kaijo(n) % MOD
    ret = ret * gyaku_kaijo(r) % MOD
    ret = ret * gyaku_kaijo(n-r) % MOD
    return ret
  
  ######Factorization######
  def factorization(n):
      arr = []
      temp = n
      for i in range(2, int(-(-n**0.5//1))+1):
          if temp%i==0:
              cnt=0
              while temp%i==0:
                  cnt+=1
                  temp //= i
              arr.append([i, cnt])
      if temp!=1:
          arr.append([temp, 1])
  
      if arr==[]:
          arr.append([n, 1])
      return arr
  
  #####LCM#####
  def lcm(a, b):
      return a * b // gcd (a, b)
  
  #############
  # Main Code #
  #############
  
  A,B,C,D = inputIL()
  
  if A+B = C+D:
    print("Balanced")
  elif A+B>C+D:
    print("Left")
  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`."}]