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





if __name__ == '__main__':
    A, B, C, D = list(map(int, input().split()))

    left_weight = A + B
    right_weight = C + D

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

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

if(A<C):
    print('Right')
elif(A>C):
    print('Left')
else:
    print('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())

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

Solution (Python):
import numpy as np
from collections import Counter
import collections
round = lambda x:(x*2+1)//2
a = list(map(float,input().split()))
a = np.array(a)
b = a[0]+a[1]
c = a[2] + a[3]
if b > c:
  print('Left')
elif b < c :
  print('Right')
else :
  print('Balanced')

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

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

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

Solution (Python):


a = raw_input()

list = a.split()

left = int(list[0])+int(list[1])
right = int(list[2])+int(list[3])

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

Solution (Python):


g = list(map(int,input().split()))
left = g[0]+g[1]
right = g[2]+g[3]
if left< right:
    print("Right")
elif left > right:
    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):
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())
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 = list(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('Balanced')
elif a + b > c + d:
    print('Left')
else:
    print('Right')

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

left = a + b
right = c + d

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

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

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())
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 = (int(i) for i in input().split())
print('Balanced' if a+b == c+d else 'Left' if a+b > c+d else 'Right')

Solution (Python):
b = input().split(" ")
a = list(map(int, b))
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())
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())

l = a+b
r = c+d
msg = "Balanced"
if l > r:
   msg = "Left"
elif l < r:
   msg = "Right"
print(msg)

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

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

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


if __name__ == '__main__':
    main()

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

Solution (Python):
a,b,c,d =list(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 = list(map(lambda x: int(x), 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())

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

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

"""
https://beta.atcoder.jp/contests/abc083/tasks/abc083_a

"""
import sys
from sys import stdin
input = stdin.readline


def solve(A, B, C, D):
    ans = 'Balanced'
    if A+B > C+D:
        ans = 'Left'
    elif A+B < C+D:
        ans = 'Right'
    return ans


def main(args):
    A, B, C, D = map(int, input().split())
    ans = solve(A, B, C, D)
    print(ans)


if __name__ == '__main__':
    main(sys.argv[1:])

Solution (Python):
l = list(map(int, input().split()))
s = sum(l[:2]) - sum(l[2:])
print(["Left", "Balanced", "Right"][(1 - (s > 0) + (s < 0))])

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):
l1,l2,r1,r2 = map(int,input().split())
if l1+l2>r1+r2:
  print('Left')
elif l1+l2<r1+r2:
  print('Right')
else:
  print('Balanced')

Solution (Python):
a,b,c,d = map(int,input().split())
right = a + b
left = c + d
 
if right < left:
  print('Right')
elif left < right:
  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")
else:
    print("Right")

Solution (Python):





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

if __name__ == "__main__": main()

Solution (Python):
X = list(map(int, input().split(' ')))
A = X[0] + X[1]
B = X[2] + X[3]
if A == B:
  print('Balanced')
elif A > B:
  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(' '))
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:
    result = "Left"
elif a + b == c + d:
    result = "Balanced"
elif a + b < c + d:
    result = "Right"
print(result)

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())
l,r = a+b,c+d

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

Solution (Python):


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

Solution (Python):
import numpy as np
import pdb
import copy

def main():
    [A, B, C, D] = map(int, raw_input().split(' '))
    left = A + B
    right = C + D
    if left >  right:
        print 'Left'
    elif right > left:
        print 'Right'
    else:
        print 'Balanced'

if __name__ == '__main__':
    main()

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

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

Solution (Python):



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

l = a+b
r = c+d

if l > r:
    ans = "Left"
elif l < r:
    ans = "Right"
else:
    ans = "Balanced"

print ans

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

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

L = int(A) + int(B)
R = int(C) + int(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 = 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=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()))

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

Solution (Python):
a, b, c, d = [int(x) for x 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("Left")
if a + b < c + d:
    print("Right")
if a + b == c + d:
    print("Balanced")

Solution (Python):
print(['Right', 'Balanced', 'Left'][max(min(sum([-x if i > 1 else x for i, x in enumerate([int(s) for s in input().split()])]), 1),-1) + 1])

Solution (Python):
s = input()
l = s.split()   

A = int(l[0])
B = int(l[1])
C = int(l[2])
D = int(l[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())

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

Solution (Python):
s = input()
l = s.split()   

A = int(l[0])
B = int(l[1])
C = int(l[2])
D = int(l[3])

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

Solution (Python):


args = input().split(' ')
left = int(args[0]) + int(args[1])
right = int(args[2]) + int(args[3])
if left > right:
    print('Left')
elif left < right:
    print('Right')
else:
    print('Balanced')

Solution (Python):


A, B, C, D = map(int, 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())

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())
a += b
c += d

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

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

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

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

Solution (Python):
import math
import itertools
import heapq
from sys import stdin, stdout, setrecursionlimit
from bisect import bisect, bisect_left, bisect_right
from collections import defaultdict, deque








def LM(t, r): return list(map(t, r))
def R(): return stdin.readline()
def RS(): return R().split()
def I(): return int(R())
def F(): return float(R())
def LI(): return LM(int,RS())
def LF(): return LM(float,RS())
def ONE_SL(): return list(input())
def ONE_IL(): return LM(int, ONE_SL())
def ALL_I(): return map(int, stdin)
def ALL_IL(): return LM(int,stdin)


def ap(f): return f.append
def pll(li): print('\n'.join(LM(str,li)))
def pljoin(li, s): print(s.join(li))





def main():
	a,b, c,d = LI()
	if a+b == c+d:
		print("Balanced")
	else:
		print("Left" if a+b>c+d else "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 = 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):
def solve():
	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")
	
solve()

Solution (Python):
A, B, C, D = list(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")
else:
    if 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):
l=input().split()
ll=len(l)
i=0
for i in range(ll):
    l[i]=int(l[i])
a=l[0]+l[1]
b=l[2]+l[3]
if a>b:
    print("Left")
elif a<b:
    print("Right")
else:
    print("Balanced")

Solution (Python):
A, B, C, D = map(int, raw_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] = 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 LI(): return [int(x) for x in input().split(" ")]
def LS(): return [str(x) for x in input().split(" ")]
def ItoS(L): return [int(x) for x in L]
def StoI(L): return [str(x) for x in L]


def solve():
    a, b, c, d = LI()
    l, r = a + b, c + d
    if l > r:
        print("Left")
    elif r > l:
        print("Right")
    else:
        print("Balanced")


solve()

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

Solution (Python):
l = map(int,raw_input().split())
if(l[0]+l[1]) > (l[2]+l[3]):
    print "Left"
elif (l[0] + l[1]) < (l[2] + l[3]):
    print "Right"
elif (l[0] + l[1]) == (l[2] + l[3]):
    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):
l = map(int,raw_input().split())
if(l[0]+l[1]) > (l[2]+l[3]):
    print "Left"
elif (l[0] + l[1]) < (l[2] + l[3]):
    print "Right"
elif (l[0] + l[1]) == (l[2] + l[3]):
    print "Balanced"

Solution (Python):

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

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

Solution (Python):
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools

sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**15
mod = 10**9+7

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)


def main():
    a,b,c,d = LI()
    a += b
    c += d
    if a>c:
        return 'Left'
    if a<c:
        return 'Right'

    return 'Balanced'



print(main())

Solution (Python):


a, b, c, d = map(int, input().rstrip().split(" "))
hidari = a + b
migi = c + d

if hidari > migi:
    print("Left")
elif hidari < migi:
    print("Right")
else:
    print("Balanced")

Solution (Python):



import sys

a, b, c, d = sys.stdin.readline().split(" ")
a = int(a)
b = int(b)
c = int(c)
d = int(d)

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(' '))
left = A + B
right = C + D
if left < right:
    print('Right')
elif left > right:
    print('Left')
else:
    print('Balanced')

Solution (Python):
a,b,c,d = [int(x) for x in raw_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())
x = a+b
y = c+d
if x<y:
	print("Right")
elif x==y:
	print("Balanced")
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):
n = list(map(int,input().split()))
left = n[0] + n[1]
right = n[2] + n[3]

if left < right:
    print("Right")
elif right < left:
    print("Left")
else:
    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, raw_input().split())

if A+B > C+D:
    print "Left"
elif A+B < C+D:
    print "Right"
else:
    print "Balanced"

Solution (Python):
n = list(map(int,input().split()))
if n[0] + n[1] > n[2] + n[3]:
  print("Left")
elif n[0] + n[1] < n[2] + n[3]:
  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 = "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):
def inputs(s):
    li = s.split(" ")
    return(li)

def libra(li):
    left = int(li[0]) + int(li[1])
    right = int(li[2]) + int(li[3])
    if(left > right):
        print("Left")
    elif(left < right):
        print("Right")
    else:
        print("Balanced")

def main():
    s = input()
    li = inputs(s)
    libra(li)

if __name__ == '__main__':
    main()

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

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

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

def main():
    ans = A + B - C - D
    if ans > 0:
        print('Left')
    elif ans < 0:
        print('Right')
    else:
        print('Balanced')

if __name__ == '__main__':
    main()

Solution (Python):

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

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

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

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


if __name__ == '__main__':
    main()

Solution (Python):
import sys
from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt, ceil, floor
from collections import deque
from bisect import bisect, bisect_left, bisect_right
from string import ascii_lowercase
from functools import lru_cache, reduce
from operator import xor
from heapq import heappush, heappop
INF = float("inf")
sys.setrecursionlimit(10**7)


dy4, dx4 = [0, -1, 0, 1], [1, 0, -1, 0]


def inside(y: int, x: int, H: int, W: int) -> bool: 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, r = A + B, C + D
    if l == r:
        print("Balanced")
    else:
        print("Left" if l > r else "Right")


if __name__ == '__main__':
    main()

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

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

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

Solution (Python):
exec"print['Balanced','Left','Right'][cmp(%s+%s,%s+%s)]"%tuple(raw_input().split())

Solution (Python):
n=list(map(int,input().split()))
l=n[0]+n[1]
r=n[2]+n[3]
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 ("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())
l = a+b
r = c+d
if l > r:
    print("Left")
elif l < r:
    print("Right")
else:
    print("Balanced")

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

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

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

Solution (Python):


a,b,c,d=map(int,raw_input().split())
wl=a+b
wr=c+d
if wl>wr:
 print 'Left'
elif wl<wr:
 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()))
ans = (A + B) - (C + D)
print('Left' if (ans > 0) else 'Right' if (ans < 0) else 'Balanced')

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

res = ""
if A + B == C + D:
	res = "Balanced"
elif A + B < C + D:
	res = "Right"
else:
	res = "Left"

print(res)

Solution (Python):
a,b,c,d = map(int, raw_input().strip().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')
if a + b > c + d: print('Left')
if a + b < c + d: 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):
import sys
import math

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

Solution (Python):
s = input()

slist = s.split(" ")

left = int(slist[0]) + int(slist[1])

right = int(slist[2]) + int(slist[3])

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

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

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

Solution (Python):

import sys
from math import *
if __name__ =="__main__":
    str_in = input()
    num = [int(n) for n in str_in.split()]
    A,B,C,D=num
    LEFT=A+B
    RIGHT=C+D
    if LEFT>RIGHT:
        print("Left")
    elif RIGHT>LEFT:
        print("Right")
    else:
        print("Balanced")

Solution (Python):
a=map(int, raw_input().split())
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"