Problem:
 Score : 100 points    Problem 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.      Constraints  1\leq A,B,C,D \leq 10  All input values are integers.         Input Input is given from Standard Input in the following format:  A  B  C  D       Output Print Left if the balance scale tips to the left; print Balanced if it balances; print Right if it tips to the right.        Sample Input 1 3 8 7 1      Sample Output 1 Left  The total weight of the masses on the left pan is 11 , and the total weight of the masses on the right pan is 8 . Since 11>8 , we should print Left .       Sample Input 2 3 4 5 2      Sample Output 2 Balanced  The total weight of the masses on the left pan is 7 , and the total weight of the masses on the right pan is 7 . Since 7=7 , we should print Balanced .       Sample Input 3 1 7 6 4      Sample Output 3 Right  The total weight of the masses on the left pan is 8 , and the total weight of the masses on the right pan is 10 . Since 8<10 , we should print Right .

Solution (Python):
a,b,c,d=map(int,input().split())
if a+b>c+d:
    print("Left")
elif a+b==c+d:
    print("Balanced")
else:
    print("Right")

Solution (Python):
a,b,c,d=map(int,input().split())
print ("Left" if a+b>c+d else "Right" if a+b<c+d else "Balanced")

Solution (Python):
A, B, C, D = map(int, input().split())
if A+B == C+D:
    print("Balanced")
elif A+B > C+D:
    print("Left")
else:
    print("Right")

Solution (Python):
A, B, C, D = map(int,input().split())
print('Left' if A+B > C+D else 'Right' if A+B < C+D else 'Balanced')

Solution (Python):
A, B, C, D = map(int,input().split())
print('Left' if A+B > C+D else 'Right' if A+B < C+D else 'Balanced')

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

if (a + b) == (c + d):
    print("Balanced")
elif (a + b) < (c + d):
    print("Right")
else:
    print("Left")

Solution (Python):
A, B, C, D = map(int, input().split())
L = A + B
R = C + D

if L > R:
    print('Left')
elif L < R:
    print('Right')
else:
    print('Balanced')

Solution (Python):
a, b, c, d = map(int, input().split())
print("Left" if a + b > c + d else "Balanced" if a + b == c + d else "Right")

Solution (Python):
a,b,c,d = [int(x) for x in input().split()]
s = a+b
t = c+d
if s==t:
    print("Balanced")
elif s>t:
    print("Left")
else:
    print("Right")

Solution (Python):
A,B,C,D = map(int, input().strip().split(' '))
if A+B > C+D:
  print('Left')
elif A+B == C+D:
  print('Balanced')
else:
  print('Right')

Solution (Python):
a,b,c,d=map(int,input().split())
print('Left' if a+b>c+d else 'Right' if a+b<c+d else 'Balanced')

Solution (Python):
a, b, c, d = map(int, input().split())
if a+b > c+d:
  print("Left")
elif a+b < c+d:
  print("Right")
else:
  print("Balanced")

Solution (Python):
A,B,C,D = map(int,input().split())
if A+B > C+D:
    print("Left")
elif A+B == C+D:
    print("Balanced")
else:
    print("Right")

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

if A+B < C+D:
    print("Right")
if A+B == C+D:
    print("Balanced")
if A+B > C+D:
    print("Left")

Solution (Python):
A,B,C,D = (int(i) for i in input().split())

X = A + B
Y = C + D

if X > Y :
    print('Left')
elif X == Y:
    print('Balanced')
elif X < Y:
    print('Right')

Solution (Python):
A,B,C,D = map(int,input().split())
print(["Balanced","Left","Right"][(A+B>C+D)-(A+B<C+D)])

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

if a + b < c + d:
    print('Right')
elif a + b > c + d:
    print('Left')
else:
    print('Balanced')

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

L = A+B
R = C+D

if L > R:
    print('Left')
elif L == R:
    print('Balanced')
else:
    print('Right')

Solution (Python):
s=list(input().split())
a=int(s[0])
b=int(s[1])
c=int(s[2])
d=int(s[3])
left=a+b
right=c+d
if left>right:
  print('Left')
elif left==right:
  print('Balanced')
else:
  print('Right')

Solution (Python):
a,b,c,d=map(int,input().split())
print('Balanced' if a+b==c+d else 'Right' if a+b<c+d else 'Left')

Solution (Python):
def main():
	linie = input()
	vector = [int(x) for x in linie.split()]	
	if vector[0] + vector[1] > vector[2] + vector[3]:
		print("Left")
	if vector[0] + vector[1] == vector[2] + vector[3]:
		print("Balanced")
	if vector[0] + vector[1] < vector[2] + vector[3]:
		print("Right")
 
 
if __name__ == "__main__":
	main()

Solution (Python):
A = list(map(int, input().split()))
if A[0] + A[1] == A[2] + A[3]:
  print('Balanced')
  exit()
elif A[0] + A[1] > A[2] + A[3]:
  print('Left')
  exit()
print('Right')

Solution (Python):
a, b, c, d = map(int, input().split())
left = a + b
right = c + d
if left > right:
    print('Left')
elif right > left:
    print('Right')
else:
    print('Balanced')

Solution (Python):
a, b, c, d = map(int, input().split())
l = a + b
r = c + d
 
if l > r:
  print('Left')
elif l == r:
  print('Balanced')
else:
  print('Right')

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

print("Left" if a+b > c+d else "Balanced" if a+b == c+d else "Right")

Solution (Python):
a, b, c, d = map(int, input().split())
a = a + b
b = c + d
if a < b:
    print("Right")
elif a > b:
    print("Left")
elif a == b:
    print("Balanced")

Solution (Python):
a, b, c, d = map(int, input().split())
a = a + b
b = c + d
if a < b:
    print("Right")
elif a > b:
    print("Left")
elif a == b:
    print("Balanced")

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

if a + b > c + d:
    print('Left')
elif a + b < c + d:
    print('Right')
else:
    print('Balanced')

Solution (Python):
A, B, C, D = map(int, input().split())
if A + B > C + D:
    print("Left")
elif A + B == C + D:
    print("Balanced")
else:
    print("Right")

Solution (Python):

a,b,c,d = map(int, input().split())

l = a + b
r = c + d

if l > r:
  print('Left')
elif l < r:
  print('Right')
else:
  print('Balanced')

Solution (Python):
a, b, c, d = map(int, input().split())
if a+b > c+d:
  print("Left")
elif a+b == c+d:
  print("Balanced")
else:
  print("Right")

Solution (Python):
a, b, c, d = map(int, input().split())
print("Left" if a + b > c + d else "Balanced" if a + b == c + d else "Right")

Solution (Python):
a,b,c,d=map(int,input().split())
if a+b>c+d:
  print("Left")
elif a+b<c+d:
  print("Right")
else:
  print("Balanced")

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

if A + B > C + D :
    print('Left')
elif A + B < C + D :
    print('Right')
else :
    print('Balanced')

Solution (Python):
a,b,c,d=map(int,input().split());print('Left'if a+b>c+d else'Right'if a+b<c+d else'Balanced')

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

l = A + B
r = C + D

if l > r:
  print("Left")
elif l == r:
  print("Balanced")
elif l < r:
  print("Right")

Solution (Python):
a, b, c, d = map(int, input().split())
l = a + b
r = c + d
if l == r:
    print("Balanced")
elif l < r:
    print("Right")
else:
    print("Left")

Solution (Python):
a,b,c,d=map(int,input().split())
if a+b>c+d:
    print("Left")
elif a+b==c+d:
    print("Balanced")
else:
    print("Right")

Solution (Python):
S = input().split()
A, B, C, D = int(S[0]), int(S[1]), int(S[2]), int(S[3])
L = A + B
R = C + D
if L > R:
    print('Left')
elif L == R:
    print('Balanced')
else:
    print('Right')

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

def main():
    a, b, c, d = map(int, input().split())

    if a+b < c+d:
        print("Right")
    elif a+b == c+d:
        print("Balanced")
    else:
        print("Left")

if __name__ == "__main__":
    main()

Solution (Python):
a,b,c,d = map(int,input().split())
if a+b > c+d:
    print('Left')
elif a+b == c+d:
    print('Balanced')
else:
    print('Right')

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

if a+b > c+d:
  print('Left')
elif a+b < c+d:
  print('Right')
else:
  print('Balanced')

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

if a+b>c+d:
    print('Left')
elif a+b<c+d:
    print('Right')
else:
    print('Balanced')

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

if (A+B)==(C+D):
    print("Balanced")
elif (A+B)>(C+D):
    print("Left")
else:
    print("Right")

Solution (Python):
a,b,c,d=map(int,input().split());e=a+b-c-d;print("LBReaiflgtah nt c  e  d"[(e<0)+(e<=0)::3])

Solution (Python):
a, b, c, d = map(int,input().split())
if (a+b)>(c+d):
	print("Left")
elif (a+b)<(c+d):
	print("Right")
else: print("Balanced")

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

l, r = a + b, c + d

if l > r:
    print("Left")
elif l < r:
    print("Right")
else:
    print("Balanced")

Solution (Python):
a, b, c, d = map(int, input().split())
print("Left" if a + b > c + d else "Right" if a + b < c + d else "Balanced")

Solution (Python):
a, b, c, d = map(int, input().split())
if a + b == c + d:
    print('Balanced')
elif a + b < c + d:
    print('Right')
else:
    print('Left')

Solution (Python):
A,B,C,D=map(int,input().split())
L=A+B
R=C+D
if L<R:
  print("Right")
elif L==R:
  print("Balanced")
else:
  print("Left")

Solution (Python):
a = [int(_) for _ in input().split()]
if len(a) == 4 and all(1 <= item <= 10 for item in a):
    if a[0] + a[1] > a[2] + a[3]:
        print('Left')
    elif a[0] + a[1] == a[2] + a[3]:
        print('Balanced')
    else:
        print('Right')
else:
    print('hoge!')

Solution (Python):
a,b,c,d = map(int, input().split())
if a + b > c +d:
	print('Left')
elif a+b == c+d:
	print('Balanced')
else:
	print('Right')

Solution (Python):
a,b,c,d = map(int, input().split())
if a + b > c +d:
	print('Left')
elif a+b == c+d:
	print('Balanced')
else:
	print('Right')

Solution (Python):
num = input().split()
a, b, c, d = int(num[0]),int(num[1]),int(num[2]),int(num[3])

if a+b > c+d:
  print("Left")
elif a+b < c+d:
  print("Right")
else:
  print("Balanced")

Solution (Python):
a,b,c,d = map(int, input().split())
print('Left' if a+b>c+d else 'Right' if a+b<c+d else 'Balanced')

Solution (Python):
a, b, c, d=map(int, input().split())
print('Left' if a+b>c+d else 'Right' if a+b<c+d else 'Balanced')

Solution (Python):
a,b,c,d = map(int,input().split())
print("Left" if a + b  >  c + d else "Balanced" if a+b == c+d else "Right" )

Solution (Python):
import sys
from statistics import *
from collections import *
from operator import itemgetter

stdin = sys.stdin

ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline()

li = na()
l = sum(li[:2])
r = sum(li[2:])
if l == r:
    print('Balanced')
elif r > l:
    print('Right')
else:
    print('Left')

Solution (Python):
def resolve():
    a, b, c, d = map(int, input().split())
    if a + b == c + d:
        ans = "Balanced"
    elif a + b > c + d:
        ans = "Left"
    else:
        ans = "Right"
    print(ans)


if __name__ == "__main__":
    resolve()

Solution (Python):
A,B,C,D = map(int,input().split())
if A+B == C+D:
    print("Balanced")
elif A+B > C+D:
    print("Left")
else:
    print("Right")

Solution (Python):
a, b, c, d = map(int, input().split())
if a + b > c + d:
    print("Left")
elif a + b < c + d:
    print("Right")
else:
    print("Balanced")

Solution (Python):
a, b, c, d = map(int,input().split())
A = ["Left", "Balanced", "Right"]
print(A[int((c+d) > (a+b)) - int((a+b) > (c+d)) + 1])

Solution (Python):
a,b,c,d = map(int,input().split())
if a+b == c+d:
  print('Balanced')
elif a+b > c+d:
  print('Left')
else:
  print('Right')

Solution (Python):
import sys
input = sys.stdin.readline
a,b,c,d=map(int,input().split())

l=a+b
r=c+d
if l==r:
  print('Balanced')
elif l>r:
  print('Left')
else:
  print('Right')

Solution (Python):


def main():

    A,B,C,D = map(int,input().split())
    left = A+B
    right = C+D

    if left > right:
        print('Left')
    elif left < right:
        print('Right')
    else:
        print('Balanced')


if __name__== "__main__":
    main()

Solution (Python):
a,b,c,d = map(int,input().split())
l,r=a+b,c+d
print("Left") if l>r else print("Right") if l<r else print("Balanced")

Solution (Python):
a,b,c,d=map(int,input().split());print("Balanced") if a+b==c+d else print("RLiegfhtt"[a+b>c+d::2])

Solution (Python):
A, B, C, D = map(int, input().split())
if A+B > C+D:
    print('Left')
elif A+B < C+D:
    print('Right')
else:
    print('Balanced')

Solution (Python):
A, B, C, D = map(float, input().split())
if A+B == C+D:
    print("Balanced")
elif A+B > C+D:
    print("Left")
else:
    print("Right")

Solution (Python):


a,b,c,d = map(int, input().split())

if a+b == c+d:
    print("Balanced")
elif a+b > c+d:
    print("Left")
else:
    print("Right")

Solution (Python):
a,b,c,d = [int(j) for j in input().split()]

ab = a+b
cd = c+d

if ab==cd:
  print("Balanced")
elif ab>cd:
  print("Left")
else:
  print("Right")

Solution (Python):
a, b, c, d = map(int, input().split())
if a + b > c + d:
    print("Left")
elif a + b == c + d:
    print("Balanced")
else:
    print("Right")

Solution (Python):
a,b,c,d=map(int,input().split())
if a+b>c+d:
  print("Left")
elif a+b==c+d:
  print("Balanced")
elif a+b<c+d:
  print("Right")

Solution (Python):
a,b,c,d = map(int,input().split())
print("Left" if a+b>c+d else "Balanced" if a+b==c+d else "Right")

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

left = a + b
right = c + d

print("Left" if left > right else "Balanced" if left == right else "Right")

Solution (Python):
A, B, C, D = map(int, input().split())
L = A+B
R = C+D
if L > R:
  print("Left")
if L == R:
  print("Balanced")
if L < R:
  print("Right")

Solution (Python):
A,B,C,D = map(int,input().split())
LEFT = A+B
RIGHT = C+D

if LEFT > RIGHT:
    print("Left")
elif LEFT < RIGHT:
    print("Right")
else:
    print("Balanced")

Solution (Python):
a, b, c, d = map(int, input().split())
print('Left' if a + b > c + d else 'Right' if a + b < c + d else 'Balanced')

Solution (Python):
a,b,c,d = map(int, input().split())
l=a+b
r=c+d
print("Left" if l>r else "Balanced" if l==r else "Right")

Solution (Python):
a, b, c, d = map(int,input().split())
if a + b > c + d:
    print('Left')
elif a + b < c + d:
    print('Right')
else:
    print('Balanced')

Solution (Python):
a, b, c, d = map(int, input().split())
if a + b > c + d:
    print('Left')
elif a + b < c + d:
    print("Right")
else:
    print("Balanced")

Solution (Python):
A,B,C,D = list(map(int,input().split()))
w1 = A+B
w2 = C+D

if w1<w2:
  print("Right")
elif w1==w2:
  print("Balanced")
else:
  print("Left")

Solution (Python):
if __name__ == '__main__':
  A, B, C, D = map(int, input().split())
  if A+B > C+D:
    print('Left')
  elif A+B < C+D:
    print('Right')
  else:
    print('Balanced')

Solution (Python):
a,b,c,d = map(int, input().split())
L,R = a+b, c+d
print("Left" if L>R else "Balanced" if L==R else "Right")

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

l = a+b
r = c+d

if r > l:
  print('Right')
elif r == l:
  print('Balanced')
else:
  print('Left')

Solution (Python):
a,b,c,d=map(int,input().split())
print('Left' if a+b>c+d else'Balanced' if a+b==c+d else 'Right')

Solution (Python):
A,B,C,D=map(int,input().split())
AB=A+B
CD=C+D
print("Left" if AB>CD else  "Right" if CD>AB else "Balanced")

Solution (Python):
a,b,c,d = map(int,input().split())
print('Left' if a+b > c+d else'Balanced' if a+b == c+d else 'Right')

Solution (Python):
(a, b, c, d) = (int(tok) for tok in input().split())
l = a + b
r = c + d

print("Balanced" if l == r else "Left" if l > r else "Right")

Solution (Python):
A, B, C, D = map(int, input().split())
if A + B == C + D:
    print("Balanced")
elif A + B > C + D:
    print("Left")
else:
    print("Right")

Solution (Python):
a, b, c, d = map(int, input().split())
print('Left' if a + b > c + d else 'Right' if a + b < c + d else 'Balanced')

Solution (Python):
A,B,C,D=map(int,input().split())
if (A+B)<(C+D):
   print("Right")
elif (A+B)==(C+D):
   print("Balanced")
else:
   print("Left")

Solution (Python):
a,b,c,d = map(int,input().split())
a+=b
c+=d
if a > c:
    print('Left')
elif a == c:
    print('Balanced')
else:
    print('Right')

Solution (Python):
def main():
    A, B, C, D = map(int, input().split())
    if A+B == C+D:
        return "Balanced"
    elif A+B > C+D:
        return "Left"
    else:
        return "Right"

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

Solution (Python):
a,b,c,d = map(int, input().split())
if a + b > c + d:
  print("Left")
elif a + b == c + d:
  print("Balanced")
else:
  print("Right")

Solution (Python):
a,b,c,d = (int(i) for i in input().split())
l = a+b
r = c+d
if l == r:
    print("Balanced")
else:
    print("Left" if l > r else "Right")

Solution (Python):
A, B, C, D = map(int, input().split())
if A+B>C+D:
  print("Left")
elif A+B==C+D:
  print("Balanced")
else:
  print("Right")

Solution (Python):
a, b, c, d = map(int, input().split())
print('Left' if a+b > c+d else 'Balanced' if a+b == c+d else 'Right')

Solution (Python):
def main():
    a,b,c,d = map(int,input().split())
    if(a+b>c+d):
        print("Left")
    elif(a+b<c+d):
        print("Right")
    else:
        print("Balanced")
main()

Solution (Python):
a,b,c,d=map(int,input().split())
print("Left" if a+b>c+d else "Right" if a+b<c+d else "Balanced")

Solution (Python):
a,b,c,d = map(int, input().split())
if (a+b) > (c+d):
    print('Left')
if (a+b) == (c+d):
    print('Balanced')
if (a+b) < (c+d):
    print('Right')

Solution (Python):
a,b,c,d=map(int,input().split())
print('Left' if(a+b)>(c+d) else 'Right' if(a+b)<(c+d) else 'Balanced')

Solution (Python):
a, b, c, d = map(int, input().split())
L = a + b
R = c + d
if L > R: print("Left")
elif L < R: print("Right")
else: print("Balanced")

Solution (Python):
a, b, c, d = map(int, input().split())
l = a+b
r = c+d
print('Left' if l > r else 'Right' if l < r else 'Balanced')

Solution (Python):
a,b,c,d=map(int,input().split())
if a+b>c+d:
  print("Left")
elif a+b==c+d:
  print("Balanced")
else:
  print("Right")

Solution (Python):
A,B,C,D = map(int,input().split())
diff = (A+B)-(C+D)
print('Left' if 0<diff else 'Right' if diff<0 else 'Balanced')

Solution (Python):
w = list(map(int, input().split()))
l, r = sum(w[:2]), sum(w[2:])
print("Left" if l>r else "Right" if l<r else "Balanced")

Solution (Python):
def test():
    a,b,c,d = map(int,input().split())
    if a+b < c+d:
        print("Right")
    elif a+b > c+d:
        print("Left")
    else:
        print("Balanced")


if __name__ == "__main__":
    test()

Solution (Python):
A, B, C, D = map(int, input().split())
l = A+B
r = C+D
if l > r:
    print('Left')
elif l == r:
    print('Balanced')
else:
    print('Right')

Solution (Python):
A, B, C, D = map(int, input().split())
L, R = A + B, C + D
print("Left" if L > R else "Right" if L < R else "Balanced")

Solution (Python):
A, B, C, D = map(int, input().split())
n = A + B - C - D
print("Left" if n > 0 else "Balanced" if n == 0 else "Right")

Solution (Python):
a, b, c, d = map(int, input().split())
l = a + b
r = c + d
if l > r:
    print("Left")
elif l < r:
    print("Right")
else:
    print("Balanced")

Solution (Python):
a, b, c, d = map(int, input().split())
l = a + b
r = c + d
print('Left' if l > r else 'Right' if l < r else 'Balanced')

Solution (Python):
a,b,c,d=map(int,input().split())
print("Left" if a+b>c+d else "Right" if a+b<c+d else "Balanced")

Solution (Python):
import math
import sys
from itertools import accumulate
from functools import reduce
import queue
from fractions import gcd

def lcm(a, b):
    return a * b // gcd(a, b)

def combination_count(n, r):
    return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))

def permutations_count(n, r):
    return math.factorial(n) // math.factorial(n - r)

sys.setrecursionlimit(10000)

mod = 1000000007

"""

a = 100
b = 0.987654321
print("{0:06d}-{1:6f}".format(a,b))
000100-0.987654


char_list = list("abcd") 



    = sys.stdin.readline().rstrip()
    = list(sys.stdin.readline().rstrip())


    = int(sys.stdin.readline())
    = map(int, sys.stdin.readline().split())
    = list(map(int, sys.stdin.readline().split()))
    = [list(map(int,list(sys.stdin.readline().split()))) for i in range(h)]  
"""

if __name__ == "__main__":
    A, B, C, D = map(int, sys.stdin.readline().split())
    L = A + B
    R = C + D
    if L > R:
        print("Left")
    elif R > L:
        print("Right")
    else:
        print("Balanced")

Solution (Python):
A,B,C,D=[int(x) for x in input().split()]
A+=B
C+=D
if A==C:
  print('Balanced')
elif A>C:
  print('Left')
else:
  print('Right')

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

if A+B>C+D:
    print('Left')
elif A+B==C+D:
    print('Balanced')
else :
    print('Right')

Solution (Python):
A,B,C,D=map(int,input().split())
x=A+B-C-D
if x>0:
    print("Left")
elif x==0:
    print("Balanced")
else:
    print("Right")

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

if a+b < c+d:
    print("Right")
elif a+b > c+d:
    print("Left")
else:
    print("Balanced")

Solution (Python):
from sys import stdin

a,b,c,d = [int(x) for x in stdin.readline().rstrip().split()]
if a+b < c+d:
  print('Right')
elif a+b > c+d:
  print('Left')
else:
  print('Balanced')

Solution (Python):
a,b,c,d = map(int,input().split())
l = a+b
r = c+d
print("Left" if l>r else "Right" if l<r else "Balanced")

Solution (Python):
a,b,c,d = map(int, input().split())
print('Left' if a+b > c+d else'Right' if a+b<c+d else'Balanced')

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

print('Right' if a+b < c+d else 'Left' if a+b > c+d else 'Balanced')

Solution (Python):
a,b,c,d=map(int,input().split())
print("Left" if a+b>c+d else "Balanced" if a+b==c+d else "Right")

Solution (Python):
a, b, c, d = map(int, input().split())
if a + b > c + d:
  print("Left")
elif a + b < c + d:
  print("Right")
else:
  print("Balanced")

Solution (Python):
a, b, c, d = map(int, input().split())
l = a+b
r = c+d
if l>r:
    print('Left')
elif r>l:
    print('Right')
elif r==l:
    print('Balanced')

Solution (Python):
a,b,c,d=list(map(int,input().split()))
print("Left" if a+b>c+d else "Right" if a+b<c+d else "Balanced")

Solution (Python):
a,b,c,d = map(int,input().split())
if a+b < c+d:
    print("Right")
elif a+b == c+d:
    print("Balanced")
else:
    print("Left")

Solution (Python):
a,b,c,d=map(int,input().split())
print("Left" if a+b>c+d else "Right" if a+b<c+d else "Balanced")

Solution (Python):
a,b,c,d=map(int,input().split())
print('Left' if a+b>c+d else 'Right' if a+b<c+d else 'Balanced')

Solution (Python):
S = list(map(int,open(0).read().split()))
L = sum(S[:2])
R = sum(S[2:])
if L-R >0:
  print("Left")
elif L-R<0:
  print("Right")
else:
  print("Balanced")

Solution (Python):
a,b,c,d = map(int,input().split())
l = a+b
r = c+d
print("Left" if l > r else "Balanced" if l == r else "Right")

Solution (Python):
A,B,C,D = map(int,input().split())
print("Left" if A + B > C + D else "Balanced" if A + B == C + D else "Right")

Solution (Python):
A,B,C,D = map(int,input().split())
print("Left" if A + B > C + D else "Balanced" if A + B == C + D else "Right")

Solution (Python):
a,b,c,d=map(int,input().split())
A=a+b
C=c+d
print("Left" if A>C else "Balanced" if A==C else "Right")

Solution (Python):
A,B,C,D = map(int, input().split())
if A+B > C+D:
    print("Left")
elif A+B < C+D:
    print("Right")
else:
    print("Balanced")

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

print ("Left" if A+B > C+D else "Right" if A+B < C+D else "Balanced")

Solution (Python):
a,b,c,d=map(int,input().split())
print(((("Balanced","Left")[c+d<a+b]),"Right")[a+b<c+d])

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

L = A + B
R = C + D

if L > R:
    print('Left')
elif L < R:
    print('Right')
else:
    print('Balanced')

Solution (Python):
a,b,c,d=map(int,input().split())
l = a+b
r = c+d
if l > r:
  print('Left')
elif l < r:
  print('Right')
else:
  print('Balanced')

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

print(['RLiegfhtt'[A+B>C+D::2],'Balanced'][A+B==C+D])

Solution (Python):
a,b,c,d = map(int,input().split())
print("Left" if a+b > c+d else "Balanced" if (a+b) == (c+d) else "Right")

Solution (Python):
a,b,c,d=map(int,input().split())
if (a+b)>(c+d):
  print('Left')
elif (a+b)==(c+d):
  print('Balanced')
else:
  print('Right')

Solution (Python):

a, b, c, d = map(int, input().split())
if (a+b) > (c+d):
    print('Left')
elif (a+b) == (c+d):
    print('Balanced')
else:
    print('Right')

Solution (Python):
a, b, c, d = map(int, input().split(' '))
if a + b > c + d:
    print('Left')
elif a + b < c + d:
    print('Right')
else:
    print('Balanced')

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

if a+b > c+d :
  print('Left')
  
elif a+b == c+d :
  print('Balanced')

elif a+b < c+d :
  print('Right')

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

if a+b > c+d:
  print("Left")
elif a+b < c+d:
  print("Right")
else:
  print("Balanced")

Solution (Python):
a,b,c,d=map(int,input().split())
l=a+b
r=c+d
if l<r:
  print('Right')
elif l>r:
  print('Left')
else:
  print('Balanced')

Solution (Python):
a,b,c,d=map(int,input().split())
if a+b>c+d:
    print('Left')
elif a+b<c+d:
    print('Right')
else:
    print('Balanced')

Solution (Python):

a,b,c,d = map(int,input().split())
l = a + b
r = c + d
if l == r:
  print('Balanced')
elif l > r:
  print('Left')
else:
  print('Right')

Solution (Python):
a, b, c, d = map(int, input().split())
if a + b == c + d:
    print("Balanced")
elif a + b > c + d:
    print("Left")
elif a + b < c + d:
    print("Right")

Solution (Python):


A, B, C, D = map(int, input().rstrip().split())

if A+B > C+D:
    print("Left")
elif A+B == C+D:
    print("Balanced")
elif A+B < C+D:
    print("Right")

Solution (Python):
a,b,c,d = map(int,input().split())
if a+b > c+d:
  print("Left")
elif a+b == c+d:
  print("Balanced")
else:
  print("Right")

Solution (Python):
a,b,c,d=map(int,input().split()[:4])

left=a+b
right=c+d
if left>right:
    print('Left')
elif left<right:
    print('Right')
else:
    print('Balanced')

Solution (Python):
w = list(map(int,input().split(' ')))

R = w[2]+w[3]
L = w[0]+w[1]

if L==R:
  print('Balanced')
elif L<R:
  print('Right')
else:
  print('Left')

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

if A + B > C + D:
    print('Left')
elif A + B == C + D:
    print('Balanced')
elif A + B < C + D:
    print('Right')

Solution (Python):
A, B, C, D = map(int, input().split())
if A + B > C + D:
    print('Left')
elif A + B < C + D:
    print('Right')
else:
    print('Balanced')

Solution (Python):
a, b, c, d = list(map(int, input().split()))
if a+b>c+d:
    print("Left")
elif a+b<c+d:
    print("Right")
else:
    print("Balanced")

Solution (Python):
a,b,c,d = map(int,input().split())
if a+b>c+d:
    print("Left")
elif a+b== c+d:
    print("Balanced")
else:
    print("Right")

Solution (Python):
a,b,c,d = map(int,input().split())
if a+b >c+d:
  print("Left")
elif a+b <c+d:
  print("Right")
else:
  print("Balanced")

Solution (Python):
a,b,c,d=map(int,input().split())
if a+b>c+d:
  print("Left")
elif a+b<c+d:
  print("Right")
else:
  print("Balanced")

Solution (Python):
A, B, C, D = list(map(int,input().split()))
l = A + B
r = C + D
if l > r:
  print("Left")
elif l < r:
  print("Right")
else:
  print("Balanced")

Solution (Python):
a, b, c, d = list(map(int, input().split()))

if a + b > c + d:
    ans = 'Left'
elif a + b == c+ d:
    ans = 'Balanced'
else:
    ans = 'Right'

print(ans)

Solution (Python):
a, b, c, d = map(int, input().split())
if a+b > c+d:
    print('Left')
elif a+b < c+d:
    print('Right')
else:
    print('Balanced')

Solution (Python):
A,B,C,D = map(int, input().split())
if A+B > C+D:
  print('Left')
elif A+B < C+D:
  print('Right')
else:
  print('Balanced')

Solution (Python):

import sys
INF = float("inf")


def solve(A: int, B: int, C: int, D: int):
    if A+B < C+D:
        print("Right")
    elif A+B == C+D:
        print("Balanced")
    else:
        print("Left")
    return


def main():

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


if __name__ == '__main__':
    main()

Solution (Python):
a,b,c,d = map(int, input().split())
lw = a + b
rw = c + d

if lw == rw:
    print("Balanced")
elif lw < rw:
    print("Right")
else:
    print("Left")

Solution (Python):
A,B,C,D = map(int,input().split())
L=A+B
R=C+D
if L>R:
  print("Left")
elif L==R:
  print("Balanced")
else:
  print("Right")

Solution (Python):
A,B,C,D = map(int,input().split())
if (A+B)>(C+D):
  print("Left")
elif (A+B)<(C+D):
  print("Right")
else:
  print("Balanced")

Solution (Python):
A,B,C,D=map(int, input().split())
if A+B == C+D:
  print("Balanced")
elif A+B > C+D:
  print("Left")
else:
  print("Right")

Solution (Python):



A, B, C, D = map(int, input().split())


if (A + B) > (C + D):
    ans = 'Left'
elif (A + B) < (C + D):
    ans = 'Right'
else:
    ans = 'Balanced'


print(ans)

Solution (Python):
a=list(map(int,input().split()))
b=(a[0]+a[1])/(a[2]+a[3])
if b>1:
    print("Left")
elif b==1:
    print("Balanced")
else:
    print("Right")

Solution (Python):
a,b,c,d=map(int,input().split())
if a+b==c+d:
  print('Balanced')
elif a+b<c+d:
  print('Right')
else:
  print('Left')

Solution (Python):
a,b,c,d = map(int,input().split())
if a+b > c+d:
  print('Left')
elif c+d > a+b:
  print('Right')
else:
  print('Balanced')

Solution (Python):
A, B, C, D = map(int, input().split())
if A + B == C + D:
  print('Balanced')
elif A + B > C + D:
  print('Left')
else:
  print('Right')

Solution (Python):
a,b,c,d = map(int,input().split())
if (a+b) > (c+d):
  print('Left')
elif (a+b) == (c+d):
  print('Balanced')
else:
  print('Right')

Solution (Python):
a, b, c, d = map(int, input().split())
left = a + b
right = c + d
if left > right:
  print('Left')
elif left == right:
  print('Balanced')
else:
  print('Right')

Solution (Python):
a,b,c,d = list(map(int,input().split(" ")))
if (a + b) > (c + d):
  print("Left")
elif (a + b) < (c + d):
  print("Right")
else:
  print("Balanced")

Solution (Python):
a, b, c, d = map(int, input().split())
if a + b > c + d:
  print('Left')
elif a + b == c + d:
  print('Balanced')
else:
  print('Right')

Solution (Python):
i1 = input().split(' ')
a=int(i1[0])+int(i1[1])
b=int(i1[2])+int(i1[3])

if a>b:
  print("Left")
elif a==b:
  print("Balanced")
else:
  print("Right")

Solution (Python):
weight = list(map(int, input().split()))
if weight[0]+weight[1] > weight[2]+weight[3]:
  print('Left')
elif weight[0]+weight[1] < weight[2]+weight[3]:
  print('Right')
else:
  print('Balanced')

Solution (Python):
a,b,c,d=map(int,input().split())
L=a+b
R=c+d
if L>R:
    print('Left')
elif L==R:
    print('Balanced')
else:
    print('Right')

Solution (Python):
a,b,c,d=map(int,input().split())
if a+b>c+d:
  print("Left")
elif a+b<c+d:
  print("Right")
else:
  print("Balanced")

Solution (Python):
a,b,c,d = map(int,input().split())
if a+b > c+d:
    print('Left')
elif a+b < c+d:
    print('Right')
elif a+b == c+d:
    print('Balanced')

Solution (Python):
A,B,C,D = list(map(int,input().split()))
w1 = A+B
w2 = C+D

if w1<w2:
  print("Right")
elif w2<w1:
  print("Left")
else:
  print("Balanced")

Solution (Python):
a, b, c, d = map(int, input().split())
l = a + b
r = c + d
if l > r:  print('Left')
if l == r: print('Balanced')
if l < r:  print('Right')