Problem:
 Score : 100 points    Problem Statement A balance scale tips to the left if L>R , where L is the total weight of the masses on the left pan and R is the total weight of the masses on the right pan. Similarly, it balances if L=R , and tips to the right if L<R .  Takahashi placed a mass of weight A and a mass of weight B on the left pan of a balance scale, and placed a mass of weight C and a mass of weight D on the right pan.  Print Left if the balance scale tips to the left; print Balanced if it balances; print Right if it tips to the right.      Constraints  1\leq A,B,C,D \leq 10  All input values are integers.         Input Input is given from Standard Input in the following format:  A  B  C  D       Output Print Left if the balance scale tips to the left; print Balanced if it balances; print Right if it tips to the right.        Sample Input 1 3 8 7 1      Sample Output 1 Left  The total weight of the masses on the left pan is 11 , and the total weight of the masses on the right pan is 8 . Since 11>8 , we should print Left .       Sample Input 2 3 4 5 2      Sample Output 2 Balanced  The total weight of the masses on the left pan is 7 , and the total weight of the masses on the right pan is 7 . Since 7=7 , we should print Balanced .       Sample Input 3 1 7 6 4      Sample Output 3 Right  The total weight of the masses on the left pan is 8 , and the total weight of the masses on the right pan is 10 . Since 8<10 , we should print Right .

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

if A + B > C + D:
  print('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):
import bisect,collections,copy,heapq,itertools,math,string
import sys
def I():
    
     return int(sys.stdin.readline().rstrip())
def LI():
    
     return list(map(int,sys.stdin.readline().rstrip().split()))
def S():
    
     return sys.stdin.readline().rstrip()
def LS():
    
     return list(sys.stdin.readline().rstrip().split())

A,B,C,D,=LI()

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

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

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

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

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

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

Solution (Python):
lst = input().split()

d = (int(lst[0]) + int(lst[1])) - (int(lst[2]) + int(lst[3]))

if d == 0:
   print('Balanced')
elif 0 < d:
   print('Left')
else:
   print('Right')

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

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

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

Solution (Python):

import sys
sys.setrecursionlimit(10**6)

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

e = a+b
f = c+d
if e > f:
    print("Left")
if e == f:
    print("Balanced")
if e < f:
    print("Right")

Solution (Python):
import bisect, collections, copy, heapq, itertools, math, string, sys
input = lambda: sys.stdin.readline().rstrip() 
sys.setrecursionlimit(10**7)
INF = float('inf')
def I(): return int(input())
def F(): return float(input())
def SS(): return input()
def LI(): return [int(x) for x in input().split()]
def LI_(): return [int(x)-1 for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LSS(): return input().split()

def resolve():
    A, B, C, D = LI()

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

if __name__ == '__main__':
    resolve()

Solution (Python):

A,B,C,D=map(int,input().split())
if (1<=A and A<=10)and(1<=B and B<=10)and(1<=C and C<=10)and(1<=D and D<=10):
    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] = list(map(int,input().split()))
L,R = A+B, 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 "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(" "))
print("Balanced") if a+b==c+d else print("Right") if a+b<c+d 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, 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=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('Balanced')
elif x > y:
  print('Left')
else:
  print('Right')

Solution (Python):
import sys
mapin = lambda: map(int, sys.stdin.readline().split())
listin = lambda: list(map(int, sys.stdin.readline().split()))
inp = lambda: sys.stdin.readline()
A,B,C,D = mapin()
l = A + B;r = C + D
if l < r:print("Right")
elif l > r:print("Left")
else:print("Balanced")

Solution (Python):
a = input().split()
a = [int(j) for j in a]
a.append(a[:2])
a.append(a[2:4])
if sum(a[4]) > sum(a[5]):
    print("Left")
if sum(a[4]) == sum(a[5]):
    print("Balanced")
if sum(a[4]) < sum(a[5]):
    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())
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

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

Solution (Python):
import math





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


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

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):
left_a, left_b, right_a, right_b = map(int, input().split())

left_weight = left_a + left_b
right_weight = right_a + right_b

if left_weight == right_weight:
    print('Balanced')
elif left_weight > right_weight:
    print('Left')
elif right_weight > left_weight:
    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):
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")


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

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

Solution (Python):



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

ab = A + B
cd = C + D
result = 'Balanced'

if ab > cd:
    result = 'Left'
elif ab < cd:
    result = 'Right'

print(result)

Solution (Python):
import sys

readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)


def main():
    x = list(map(int, readline().split()))

    first = x[0] + x[1]
    second = x[2] + x[3]

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


if __name__ == '__main__':
    main()

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

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

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 = (int(x) for x in 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())

left_dish = A + B
right_dish = C + D

if left_dish > right_dish:
    print('Left')
elif left_dish < right_dish:
    print('Right')
elif left_dish == right_dish:
    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())


result = "ret"

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

print(result)

Solution (Python):

















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


result = "ret"

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

print(result)

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("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("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('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
print("Left" if L>R else "Right" if R>L else "Balanced")

Solution (Python):




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


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


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

Solution (Python):
left1, left2, right1, right2 = map(int, input().split())
if right1 + right2 > left1 + left2:
    print('Right')
elif right1 + right2 < left1 + left2:
    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("Balanced")
else:
  print("Left")

Solution (Python):

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


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

Solution (Python):

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


LWeight = A + B
RWeight = C + D


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

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

Solution (Python):

A,B,C,D = map(int,input().split())
if A + B > C + D:

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

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

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

Solution (Python):
S = input()
S_list = S.split()

L = int(S_list[0]) + int(S_list[1])
R = int(S_list[2]) + int(S_list[3])
 
if L-R>0:
    print("Left")
elif L-R<0:
    print("Right")
else:
    print("Balanced")

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

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

Solution (Python):



from fractions import gcd
from itertools import combinations,permutations,accumulate, product 

from collections import deque,defaultdict,Counter
import decimal
import re












import sys
sys.setrecursionlimit(10000000)


mod = 998244353
def readInts():
  return list(map(int,input().split()))
def I():
  return int(input())
a,b,c,d = readInts()
left = a+b
right = c+d
print('Left' if left > right else ('Balanced' if left == right else '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("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())

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

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

Solution (Python):


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

if __name__ == "__main__":
    main()

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())
left, right = A + B, 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('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('Balanced'if a+b==c+d else'RLiegfhtt'[a+b>c+d::2])

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

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

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

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

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

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

if sum(l[:2]) == sum(l[2:]): print('Balanced')
elif sum(l[:2]) > sum(l[2:]): 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())
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(x) for x in input().split())
L = a+b
R = c+d
if L == R:
  print ('Balanced')
elif L > R:
  print ('Left')
else:
  print ('Right')

Solution (Python):
A = input().split(" ")
L = int(A[0])+int(A[1])
R = int(A[2])+int(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())
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):

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


if __name__ == "__main__":
    main()

Solution (Python):
import sys

read = sys.stdin.read
readline = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 8)
INF = float('inf')
MOD = 10 ** 9 + 7


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

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

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

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

Solution (Python):
import sys

read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007


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

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

    return


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):
import sys
sys.setrecursionlimit(4100000)
import math
import itertools
INF = float('inf')
from heapq import heapify, heappop, heappush

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

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


if __name__ == '__main__':
    main()

Solution (Python):
ais = map(int, raw_input().split())
if sum(ais[:2]) == sum(ais[2:]):
	print 'Balanced'
elif sum(ais[:2]) > sum(ais[2:]):
	print 'Left'
elif sum(ais[:2]) < sum(ais[2:]):
	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 = 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=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('Right')
elif a+b==c+d:
  print('Balanced')
else:
  print('Left')

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

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

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

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

Solution (Python):

















import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import accumulate, permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce
import numpy as np
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

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

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

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

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

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

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 = (int(T) for T in input().split())
L = A+B
R = C+D
print(['Balanced','Left','Right'][(L!=R)+(L<R)])

Solution (Python):
import sys
def MI(): return map(int,sys.stdin.readline().rstrip().split())

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

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

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

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

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