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("Right")

elif a + b > c + d:
    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("Balanced")
elif a + b < c + d:
	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")
elif l == r:
	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 "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("Balanced")
else:
  print("Right")

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

l = A + B
r = C + D

if l > r:
    ans = "Left"
elif l == r:
    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())
l, r = a + b, c + d
if r < l:
  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:
    print('Left')
elif a+b < c+d:
    print('Right')
else:
    print('Balanced')

Solution (Python):




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


if __name__ == '__main__':
    main()

Solution (Python):
A, B, C, D = list(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,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):



def main():
    A, B, C, D = map(int, raw_input().split())
    l = A + B
    r = C + D

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


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("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')
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())
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","Balanced","Right"][(a+b<c+d)+(a+b<=c+d)])

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")
else:
    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=map(int,input().split())
print(['Right','Left','Balanced'][(a+b>c+d)-(a+b==c+d)])

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

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

Solution (Python):
def sign(n):
    if n == 0:
        return 0
    return n // abs(n)

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

print(["Left", "Balanced", "Right"][1 - sign(A + B - C - D)])

Solution (Python):
def sign(n):
    if n == 0:
        return 0
    else:
        return n // abs(n)

A, B, C, D = map(int, input().split())
print(["Left", "Balanced", "Right"][1 - sign(A + B - C - D)])

Solution (Python):
a,b,c,d = (int(i) for i in 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("Balanced")
else:
    print("Left" if A+B>C+D 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):


from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt
from collections import deque
from bisect import bisect, bisect_left, bisect_right
from string import ascii_lowercase
from functools import lru_cache
import sys
sys.setrecursionlimit(10000)
INF = float("inf")
YES, Yes, yes, NO, No, no = "YES", "Yes", "yes", "NO", "No", "no"
dy4, dx4 = [0, 1, 0, -1], [1, 0, -1, 0]


def inside(y, x, H, W):
    return 0 <= y < H and 0 <= x < W


def ceil(a, b):
    return (a + b - 1) // b


def main():
    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")
        

if __name__ == '__main__':
    main()

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("Right")
elif a+b == c+d:
  print("Balanced")
else:
  print("Left")

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(A+B==C+D):
  print("Balanced")
else:
  print("Right")

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

Solution (Python):
lis =input().split()
left=int(lis[0])+int(lis[1])
right=int(lis[2])+int(lis[3])
if left>right:
    print("Left")
elif left<right:
    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):
from collections import defaultdict
import sys,heapq,bisect,math,itertools,string,queue,datetime
sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
eps = 10**-7
def inpl(): return list(map(int, input().split()))
def inpl_s(): return list(input().split())

A,B,C,D = inpl()

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

Solution (Python):

import math,string,itertools,fractions,heapq,collections,re,array,bisect

def ln():
    return map(int, input().split())

A,B,C,D = ln()

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())

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("Right")
else:
    print("Balanced")

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())
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("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("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())
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')
elif A+B == C+D:
  print('Balanced')
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):
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("Right" if c+d>a+b else "Left" if c+d<a+b 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())
lw = A+B 
rw = C+D 
if lw > rw:
    print('Left')
elif lw < rw:
    print('Right')
else:
    print('Balanced')

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

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

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('Balanced')
    elif a + b < c + d:
        print('Right')


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())
sgns = ('>', '==', '<')
d_sa = {
    sgn:ans
    for sgn, ans in
    zip(sgns, ('Left', 'Balanced', 'Right'))
    }
for sgn in sgns:
    f = str(a+b)+sgn+str(c+d)
    if eval(f):
        print(d_sa[sgn])
        exit()

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('Balanced')
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())
l = [a,b]
r = [c,d]
if sum(l) >= sum(r):
    if sum(l) == sum(r):
        print("Balanced")
    else:
        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):

n=[int(i) for i in input().split()]
if(n[0]+n[1]==n[2]+n[3]):
  print("Balanced")
elif(n[0]+n[1]<n[2]+n[3]):
  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):
a, b, c, d = (int(x) for x in raw_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 l<r:
  print('Right')
else:
  print('Balanced')

Solution (Python):
a = list(map(int, input().split()))
if sum(a[0:2]) == sum(a[2:]):
    print("Balanced")
elif sum(a[0:2]) > sum(a[2:]):
    print("Left")
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):
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 = list(map(int, input().split()))
X = A + B
Y = C + D
if X > Y:
	print("Left")
elif X == Y:
	print("Balanced")
else:
	print("Right")

Solution (Python):
a, b, c, d = input().split(" ")
a = int(a)
b = int(b)
c = int(c)
d = int(d)
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(['Balanced','Left','Right'][(a+b>c+d)-(a+b<c+d)])

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

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

Solution (Python):
while True:
    a = input().split()
    N = [int(i) for i in a]
    A,B,C,D = N
    if  (A or B or C or D) < 1 or (A or B or C or D) > 10:
        continue
    if A+B > C+D:
        print('Left')
    if A+B < C+D:
        print('Right')
    if A+B == C+D:
        print('Balanced')
    break

Solution (Python):
a,b,c,d = input().split()
A = int(a)
B = int(b)
C = int(c)
D = int(d)

left = A+B
right = C+D

if(left>right):
	print("Left")
elif(left<right):
	print("Right")
elif(left==right):
	print("Balanced")

Solution (Python):
[a,b,c,d]=[int(i) for i in 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())
sa=a+b-c-d
if sa>0:
  print('Left')
elif sa<0:
  print('Right')
else:
  print('Balanced')

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

l=A+B
r=C+D

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

Solution (Python):
w=map(int,raw_input().split())
l=sum(w[0:2])
r=sum(w[2:4])
if l>r:
  print 'Left'
elif l==r:
  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")
elif l < r:
    print("Right")
else:
    print("Left")

Solution (Python):
A, B, C, D = list(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())
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())

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("Balanced")
elif L < R:
    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("Left")
elif A+B < C+D:
    print("Right")
else:
    print("Balanced")

Solution (Python):
a = list(map(int, input().split()))
l, r = a[0] + a[1], a[2] + a[3]
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('Balanced')
    
elif A+B > C+D:
    print('Left')

else:
    print('Right')

Solution (Python):
w=[int(i) for i in input().split()]
if(w[0]+w[1] > w[2]+w[3]):
    ans = "Left"
elif(w[0]+w[1] == w[2]+w[3]):
    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("Balanced")
else:
    print("Right")

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

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

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

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

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

Solution (Python):
InA = [int(i) for i in input().split()]

if InA[0] + InA[1] > InA[2] + InA[3] :
    print ("Left")
elif InA[0] + InA[1] < InA[2] + InA[3] :
    print ("Right")
elif  InA[0] + InA[1] == InA[2] + InA[3] :
    print ("Balanced")
else:
    print ("err")

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 = [int(i) for i in 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('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):
weight = list( map( int, input().split() ) )
print( "Balanced" if( weight[0]+weight[1] == weight[2] + weight[3] ) else "Left" if( weight[0] + weight[1] > weight[2] + weight[3] ) 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("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('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("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=list(map(int,input().split()))
if a[0]+a[1]>a[2]+a[3]:
    print("Left")
elif a[0]+a[1]<a[2]+a[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 R > L:
    print("Right")
elif L == R:
    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 = (int(i) for i in 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 = map(int, input().split())
e = a + b - (c + d)
print("Left" if e>0 else "Balanced" if e==0 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(' '))
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('Balanced')
else:
    print('Right')

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

Solution (Python):
A,B,C,D=map(int,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())
x = a+b-c-d
if x == 0:
    print("Balanced")
elif x > 0:
    print("Left")
else:
    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())
e=a+b-c-d
print('Right' if e<0 else 'Balanced' if e==0 else 'Left')

Solution (Python):
x = list(map(int, input().split()))
l, r = sum(x[:2]), sum(x[2:])
if(l == r):
    result = 'Balanced'
elif(l > r):
    result = 'Left'
else:
    result = 'Right'
print(result)

Solution (Python):
a = map(int,raw_input().split())
l = a[0] + a[1]
r = a[2] + a[3]
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("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('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'if A+B>C+D else '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):
print((lambda x: "Balanced" if x[0]+x[1] == x[2]+x[3] else "Left" if x[0]+x[1] > x[2]+x[3] else "Right")(list(map(int, input().split()))))

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 print('Right')if a+b<c+d else print('Balanced')

Solution (Python):

a,b,c,d = map(int,(input().split()))
A = (a + b)
B = (c + d)
if A > B:
    print("Left")
elif A == B:
    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())
print(["Balanced","Left","Right"][a+b>c+d or-(a+b<c+d)])

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('Left')
elif a + b == c + d:
    print('Balanced')
else:
    print('Right')

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

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())
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 = list(map(int,input().split()))
l = a + b
r = c + d
if r < l:
    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("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()))

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

Solution (Python):
w,x,y,z=map(int,input().split())
if w+x<y+z:
	print("Right")
elif w+x>y+z:
	print("Left")
else:
	print("Balanced")

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):
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("Right")
elif A+B>C+D:
    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())

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):
import math
import sys

def getinputdata():

    
    array_result = []
    
    data = input()

    
    array_result.append(data.split(" "))

    flg = 1

    try:


        while flg:

            data = input()

            array_temp = []

            if(data != ""):
                
                array_result.append(data.split(" "))

                flg = 1

            else:

                flg = 0
    finally:


        return array_result





arr_data = getinputdata()

a = int(arr_data[0][0])
b = int(arr_data[0][1])
c = int(arr_data[0][2])
d = int(arr_data[0][3])


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())

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 ['Balanced','Right'][a+b<c+d])

Solution (Python):
import sys

stdin = sys.stdin

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

a,b,c,d = na()
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
f=c+d
if e>f:
  print("Left")
elif e==f:
  print("Balanced")
else:
  print("Right")

Solution (Python):
x = input().split()
a = int(x[0])
b = int(x[1])
c = int(x[2])
d = int(x[3])
e = int(a + b)
f = int(c + d)
if e < f :
    print('Right')
if e == f :
    print('Balanced')
if e > f :
    print('Left')

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())
x=a+b
y=c+d
if x<y:
    print("Right")
elif y<x:
    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())
e=a+b
f=c+d
if e>f:
  print('Left')
elif e<f:
  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=map(int,input().split())
r = next(a)
r += next(a)
r -= next(a)
r -= next(a)
print('Left' if r > 0 else 'Balanced' if r == 0 else 'Right')