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

Solution (Python):

import sys, math, itertools, heapq, collections, bisect, string
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
sys.setrecursionlimit(10**7)
inf = float('inf')
mod = 10**9+7
ans = 0 ;count = 0 ;pro = 1


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

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

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

print(ans)

Solution (Python):
A, 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(" "))

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

m = a +b -c-d

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

Solution (Python):
dbflag=""

def debug(*args):
	if ""!=dbflag: print(*args)

if ""!=dbflag: _INDATA=open(dbflag)

def readline():
	if ""!=dbflag:return _INDATA.readline()
	else: return input()


result = 0

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



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

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

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

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

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 ("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):
la,lb,ra,rb = map(int,input().split())
if la+lb > ra+rb:
    print('Left')
elif la+lb < ra+rb:
    print("Right")
else:
    print("Balanced")

Solution (Python):

import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)

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=list(map(int,input().split(" ")))
wL=A+B 
wR=C+D 

if wL<wR: 
    print("Right")
elif wL>wR: 
    print("Left")
elif wL==wR:
    print("Balanced")

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

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

Solution (Python):

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())
left = A + B
right = C + D

if left > right:
    ans = "Left"
elif left < right:
    ans = "Right"
else:
    ans = "Balanced"

print(ans)

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

A_B = (A+B)
C_D = (C+D)

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

Solution (Python):
from sys import stdin

a,b,c,d = [int(x) for x in stdin.readline().rstrip().split()]

k = a+b
j = c+d

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

Solution (Python):
def examA():
    A, B, C, D = LI()
    if A+B==C+D:
        ans= "Balanced"
    elif A+B<C+D:
        ans = "Right"
    else:
        ans = "Left"
    print(ans)


import sys,copy,bisect,itertools,heapq,math
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def S(): return sys.stdin.readline().strip()
mod = 10**9 + 7
inf = float('inf')

examA()

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

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

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

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 6)
input = sys.stdin.readline
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")

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

main()

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

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

Solution (Python):
import sys








def main():
    a, b, c, d = (int(x) for x in sys.stdin.read().split())
    left = a + b
    right = c + d
    if left > right: ans = "Left"
    elif right > left: ans = 'Right'
    else: ans = 'Balanced'
    print(ans)


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('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('Right')
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('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 = [int(s) for s 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())
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())
l = a + b
r = c + d
if l > r:
    print('Left')
elif l < r:
    print('Right')
else:
    print('Balanced')

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

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

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

left = A + B
right = C + D

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

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

Solution (Python):
from sys import stdin
A,B,C,D = [int(x) for x in stdin.readline().rstrip().split()]
if A+B > C+D:
    print("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):
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")
else:
  print("Right")

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

Solution (Python):
A,B,C,D= (int(x) for x in input().split())
left = A+ B
right = C+D

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

Solution (Python):


import sys

sys.setrecursionlimit(100000)
INF = float('inf')
MOD = 10**9+7
EPS = 10**-7





A,B,C,D = [int(x) for x in 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())
print('Left' if (A+B)>(C+D) else 'Balanced' if (A+B)==(C+D) else'Right')

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

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

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

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

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

left=A+B
right=C+D

if left>right:
  print("Left")
elif left<right:
  print("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('Right')
elif l>r:
    print('Left')
else:
    print('Balanced')

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

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

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

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

left = A + B
right = C + D

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

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

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

Solution (Python):
A, B, C, D = tuple(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())
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())
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("Right")
if A+B == C+D:
  print("Balanced")
if A+B > C+D:
  print("Left")

Solution (Python):
def slove():
    import sys
    input = sys.stdin.readline
    a, b, c, d = list(map(int, input().rstrip('\n').split()))
    ab = a + b
    cd = c + d
    if ab > cd:
        print("Left")
    elif ab < cd:
        print("Right")
    else:
        print("Balanced")


if __name__ == '__main__':
    slove()

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

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

Solution (Python):
a = list(map(int,input().split()))
A=a[0]
B=a[1]
C=a[2]
D=a[3]

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

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

Solution (Python):
a,b,c,d=[int(s) for s in 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('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 'Balanced' if A+B == C+D else 'Right')

Solution (Python):
INT = lambda: int(input())
INTM = lambda: map(int,input().split())
STRM = lambda: map(str,input().split())
STR = lambda: str(input())
LIST = lambda: list(map(int,input().split()))
LISTS = lambda: list(map(str,input().split()))
def do():
    a,b,c,d=INTM()
    if (a+b)>(c+d):
        print('Left')
    elif (a+b)==(c+d):
        print('Balanced')
    else:
        print('Right')
if __name__ == '__main__':
    do()

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

if A + B > C + D:
    print("Left")

if A + B == C + D:
    print("Balanced")

if A + B < C + D:
    print("Right")

Solution (Python):
a,b,c,d=map(int,input().split())
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("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):
def aa083():
    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')

aa083()

Solution (Python):
import sys

input = sys.stdin.readline


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

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

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

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

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

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

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

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

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

Solution (Python):
a, b, c, d = map(int, input().split())
left = a + b
right = c + d
if left > right:
    print('Left')
elif left < right:
    print('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 = A + B
R = C + D

print("Left" if L > R else "Right" if L < R else "Balanced")

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

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

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

Solution (Python):
A,B,C,D = 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 r > l:
  print("Right")
else:
  print("Balanced")

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

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

weight_left = A + B
weight_right = C + D

if weight_left > weight_right:
    print('Left')
elif weight_left < weight_right:
    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(['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("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")
  exit()
if(l<r):
  print("Right")
  exit()
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):
import sys

if sys.platform =='ios':
    sys.stdin=open('input_file.txt')
    
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")