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


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('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):
from sys import exit
A,B,C,D = [int(n) for n 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())
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("Balanced" if a+b == c+d else "RLiegfhtt"[a+b > c+d::2])

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

"""
Created on Mon Mar  4 15:01:58 2019

@author: kaned
"""
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=[int(i) for i in input().split()]
right=a+b
left=c+d
if right==left:
    print("Balanced")
elif right>left:
    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):
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())
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")
elif a+b == c+d:
  print("Balanced")

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

left = A + B
right = C + D
ans = ""

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

print(ans)

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( '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(x) for x in input().split() ]

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

print(ans)
print()

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

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

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

Solution (Python):
import bisect
import numpy as np
import sys
input = sys.stdin.readline
def IL(): return list(map(int,input().split()))
def SL(): return input().split()
def I(): return int(sys.stdin.readline())
def S(): return input()

a = IL()
l = a[0]+a[1]
r = a[2]+a[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('Balanced')
else:
  print('Right')

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):
A, 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):
if __name__ == '__main__':
    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):
int_a, int_b, int_c, int_d = map(int, input().split())

if int_a + int_b == int_c + int_d:
    print("Balanced")
elif int_a + int_b > int_c + int_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())
AB = A + B
CD = C + D

if AB > CD:
  print('Left')
elif AB < CD:
  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("Balanced")
elif left < right:
    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())
print("Left" if C + D < A + B 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):
abcd = list(int(i) for i in input().split())
left = abcd[0] + abcd[1]
right = abcd[2] + abcd[3]
if left > right:
    print("Left")
elif left == right:
    print("Balanced")
else:
    print("Right")

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

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

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

AB = A + B
CD = C + D

if AB < CD:
    print("Right")
elif AB == CD:
    print("Balanced")
else:
    print("Left")

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

Solution (Python):


import numpy as np
import random

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

print('Left' if A+B>C+D else 'Balanced' if A+B==C+D else '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())
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):
num=list(map(int,input().split()))
a=num[0]+num[1]
b=num[2]+num[3]
if a>b:
    print("Left")
elif a==b:
    print("Balanced")
else:
    print("Right")

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

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

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

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

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

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

Solution (Python):
A, B, C, D = 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("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())
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("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())
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("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())
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 = (int(i) for i in 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('Right')
else:
	print('Balanced')

Solution (Python):
import numpy as np
a, b, c, d = (int(i) for i in input().split()) 
result = 'Right' if a+b < c+d else 'Left' if a+b > c+d else 'Balanced'
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('Balanced')
else:
    print("Right")

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

Solution (Python):
A,B,C,D = (int(x) for x in 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 = (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):


def main():
    sa = input().split(' ')
    a = [int(s) for s in sa]

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

    if l > r:
        print('Left')
    elif l < r:
        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("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(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):
def abc083_a():
    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")


abc083_a()

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

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


if __name__ == '__main__':
    main()

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

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

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

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

Solution (Python):



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


if __name__ == "__main__":
    main()

Solution (Python):

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

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

Solution (Python):

print((lambda x:'Left' if x[0]+x[1]>x[2]+x[3] else ('Balanced' if x[0]+x[1]==x[2]+x[3] else 'Right'))(list(map(int, input().split()))))

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




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

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("Balanced")
elif left>right:
  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=[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())
l = a + b
r = c + d

if l == r:
    answer = 'Balanced'
elif l > r:
    answer = 'Left'
else:
    answer = 'Right'

print(answer)

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

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

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

Solution (Python):
a, b, c, d = 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())
print(["Balanced","Left","Right"][(C+D<A+B)-(C+D>A+B)])

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

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

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

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

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

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

Left=0
Right=0

Left=b[0]+b[1]
Right=b[2]+b[3]

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

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

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

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

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

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

if s>t:
  print("Left")
elif s<t:
  print("Right")
else:
  print("Balanced")

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

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

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

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

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

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

"""
Created on Sun Nov  4 21:46:51 2018

@author: sk
"""


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

s1=a+b
s2=c+d

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

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

E = A + B - (C + D)

if E > 0:
    print('Left')
elif E < 0:
    print('Right')
else:
    print('Balanced')

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

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

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):
x,y,z,w = map(int,input().split())
if x + y < z + w:
  print('Right')
elif x + y == z + w:
  print('Balanced')
else:
  print('Left')

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

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

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

Solution (Python):
A, B, C, D = map(int, raw_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()))
L = A + B
R = C + D

if L > R:
    print('Left')

elif L == R:
    print('Balanced')

else:
    print('Right')

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

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

if A+B>C+D:
    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 'RLiegfhtt'[a+b>c+d::2])

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

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

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

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

if a[0] + a[1] == a[2] + a[3]:
  print('Balanced')
elif a[0] + a[1] < a[2] + a[3]:
  print('Right')
else:
  print('Left')

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

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

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

ab = A + B
cd = C + D

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

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

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

if hoge > fuga:
    print("Left")
elif hoge == fuga:
    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 = [int(m) for m in input().split(" ")]

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

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

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

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

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