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

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

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

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


main()

Solution (Python):
import sys, os

f = lambda:list(map(int,input().split()))
if 'local' in os.environ :
    sys.stdin = open('./input.txt', 'r')

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

solve()

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

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

m=a+b
n=c+d

if m>n:
  print("Left")
elif m==n:
  print("Balanced")
else:
  print("Right")

Solution (Python):
A,B,C,D=map(int,input().split())
print('Balanced' if A+B == C+D else 'Left' 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= [int(i) for i in input().split()]
if a + b > c + d:
  print("Left")
elif a + b == c + d:
  print("Balanced")
else:
  print("Right")

Solution (Python):

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


def submit():
    a, b, c, d = read_input()

    l = a + b
    r = c + d

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


if __name__ == '__main__':
    submit()

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

Solution (Python):
a,s,d,f=map(int,input().split())
if a+s>d+f:
  print("Left")
elif a+s==d+f:
  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())

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

Solution (Python):
a = [int(i) for i in input().split()]
l = a[0] + a[1]
r = a[2] + a[3]
if l > r: s = "Left"
elif l < r: s = "Right"
else: s = "Balanced"
print(s)

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

if sum(a[0:2]) == sum(a[2:4]):
  print("Balanced")
elif sum(a[0:2]) > sum(a[2:4]):
  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):
import sys
input = sys.stdin.readline

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

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

import os

INF = float('inf')


def inp():
    return int(input())


def inpf():
    return float(input())


def inps():
    return input()


def inl():
    return list(map(int, input().split()))


def inlf():
    return list(map(float, input().split()))


def inls():
    return input().split()


def inpm(line):
    return [inp() for _ in range(line)]


def inpfm(line):
    return [inpf() for _ in range(line)]


def inpsm(line):
    return [inps() for _ in range(line)]


def inlm(line):
    return [inl() for _ in range(line)]


def inlfm(line):
    return [inlf() for _ in range(line)]


def inlsm(line):
    return [inls() for _ in range(line)]


def debug(fn):
    if not os.getenv('LOCAL'):
        return fn

    @functools.wraps(fn)
    def wrapper(*args, **kwargs):
        print('DEBUG: {}({}) -> '.format(
            fn.__name__,
            ', '.join(
                list(map(str, args)) +
                ['{}={}'.format(k, str(v)) for k, v in kwargs.items()]
            )
        ), end='')
        ret = fn(*args, **kwargs)
        print(ret)
        return ret

    return wrapper


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

Solution (Python):

a, b, c, d = list(map(int, input().rstrip().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()))
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())
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()]

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

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
print("Left" if A>B else "Right" if A<B 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")
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
print('Balanced' if left == right else 'Left' if left > right 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("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())

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=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):
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('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):



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

Solution (Python):


import sys
input = sys.stdin.readline

def io_generator():
	return input()



def main(io):
	a,b,c,d = map(int, io().split())
	
	rets=['Left', 'Balanced', 'Right']
	
	if a+b > c+d:
		return rets[0]
	elif a+b < c+d:
		return rets[2]
	else:
		return rets[1]



if __name__ == "__main__":
	io= lambda : io_generator()
	print (main(io))

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 = A+B, C+D
print(["Balanced", "Left", "Right"][(R<L) + -(R>L)])

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

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

Solution (Python):
a, b, c, d = [int(item) for item 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()))

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

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

if r < l:
    print('Left')
elif r > l:
    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(_) for _ in 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(' '))
e=a+b
f=c+d
if e>f:
    print('Left')
elif e==f:
    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()))
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 = [int(n) for n in input().split()]

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

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

Solution (Python):

from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = I()
    return l
def LIR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = LI()
    return l
def SR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = S()
    return l
def LSR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = SR()
    return l
mod = 1000000007


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


def B():
    return


def C():
    x,y = LI()
    ans = 1
    for i in range(10000000000000):
        x *= 2
        if x > y:break
        ans += 1
    print(ans)


def D():
    s = S()
    n = len(s)
    ans = n
    for i in range(n-1):
        if s[i] != s[i+1]:
            ans = min(ans,max(i+1,n-i-1))
    print(ans)


def E():
    return


def F():
    return


def G():
    return


def H():
    return


if __name__ == "__main__":
    A()

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

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

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

else:
  print('Right')

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


if __name__ == '__main__':
    print(solve(input()))

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("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())
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 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_1 = list(map(int,input().split()))

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

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())
n=a+b
m=c+d
if n>m:
  print("Left")
elif m>n:
  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("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())
right = a+b
left = c+d
if(right>left):
  print("Left")
elif(right<left):
  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())
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("Left")
else:
    print("Balanced")

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

Solution (Python):
def libra(A: int, B: int, C: int, D: int) -> str:
    if A + B > C + D:
        return 'Left'
    if A + B < C + D:
        return 'Right'
    return 'Balanced'


if __name__ == "__main__":
    A, B, C, D = map(int, input().split())
    ans = libra(A, B, C, D)
    print(ans)

Solution (Python):
o=input().split();s=sum(map(int,o));sl=sum(map(int,o[:2]))
if sl>s/2:
  m='Left'
elif sl==s/2:
  m='Balanced'
else:
  m='Right'
print(m)

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

Solution (Python):
v,b,n,m = map(int,input().split())

if v+b == n+m:
  print("Balanced")
elif v+b > n+m:
  print("Left")
else:
  print("Right")

Solution (Python):


import itertools
import collections
import bisect
import sys
input = sys.stdin.readline

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


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

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

Solution (Python):
a, b, c, d = (int(i) for i in input().split())
x=a+b
y=c+d
if x > y:
    print("Left")
if x < y:
    print("Right")
if x == y:
    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):
import sys

def main():
    input = sys.stdin.readline
    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')


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

l = a + b
r = c + d

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

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

Solution (Python):
l=list(map(int,input().split()))
L=l[0]+l[1]
R=l[2]+l[3]

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

Solution (Python):
import numpy as np

data = list(map(int, input().split()))

l = data[0] + data[1]
r = data[2] + data[3]

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

Solution (Python):
import numpy as np

data = list(map(int, input().split()))

l = data[0] + data[1]
r = data[2] + data[3]

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