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

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


if '__main__' == __name__:
    resolve()

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

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

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

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

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

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

Solution (Python):
from sys import stdin
import math

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

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

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

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, 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):
icase=0    
if icase==0:
    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())
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):
a, b, c, d = map(int, input().split())

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

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

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

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

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=input().split()
A=int(A)
B=int(B)
C=int(C)
D=int(D)

sumL=A+B
sumR=C+D


if sumL>sumR:
    print('Left')
elif sumL<sumR:
    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('Balanced')
else:
  print('Left')

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

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

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

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

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

Solution (Python):
import sys
stdin = sys.stdin

ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
nn = lambda: list(stdin.readline().split())
ns = lambda: stdin.readline().rstrip()

a,b,c,d = na()
e = a+b
f = c+d

print('Left' if e > f else 'Balanced' if e == f 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('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())
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())

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

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

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

A = a + b
B = c + d
if A == B:
  print('Balanced')
elif A > B:
  print('Left')
elif A < B:
  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):
import sys
input = sys.stdin.readline

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

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

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

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

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

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

Solution (Python):

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

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

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

Solution (Python):
import sys

a, b, c, d = map(int, sys.stdin.readline().split())
l = a + b
r = c + d

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

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

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):
import sys
import copy
import math
import bisect
import pprint
import bisect
from functools import reduce
from copy import deepcopy
from collections import deque

if __name__ == '__main__':
    a = [int(i) for i in 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):
def ii():return int(input())
def iim():return map(int,input().split())
def iil():return list(map(int,input().split()))
a,b,c,d = iim()
if a+b < c+d:
    print('Right')
elif a+b > c+d:
    print('Left')
else:
    print('Balanced')

Solution (Python):
t = [int(v) for v in input().split(' ')]
n = t[0] + t[1]
n2 = t[2] + t[3]
 
if n > n2:
  print('Left')
elif n < n2:
  print('Right')
elif n == n2:
  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 print('Left' if (A + B) > (C + D) else 'Right')

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

Solution (Python):
A,B,C,D=map(int,input().split());print('Balanced'*(A+B-C-D==0)or'RLiegfhtt'[A+B-C-D>0::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("Right")
elif L == R:
  print("Balanced")
else:
  print("Left")

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


if __name__ == "__main__":
    main()

Solution (Python):
import math


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

Solution (Python):
import sys
from math import sqrt
from collections import Counter

input = sys.stdin.readline


def I():
    return int(input())


def MI():
    return map(int, input().split())


def LI():
    return list(MI())


inf = float("inf")
mod = 10 ** 9 + 7


def main():
    a, b, c, d = MI()

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


if __name__ == "__main__":
    main()

Solution (Python):
import sys
import os

MOD = 10 ** 9 + 7


def main():
    if os.getenv("LOCAL"):
        sys.stdin = open("input.txt", "r")

    A, B, C, D = list(map(int, sys.stdin.buffer.readline().split()))
    print('Left' if A + B > C + D else 'Balanced' if A + B == C + D else 'Right')


if __name__ == '__main__':
    main()

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

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

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

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())
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())
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 "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):
l = [int(x) for x in input().split(' ')]
if l[0] + l[1] < l[2] + l[3]:
  print("Right")
elif l[0] + l[1] > l[2] + l[3]:
  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(i) for i in 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')
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 = list(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("Balanced")
elif l>r:
    print("Left")
else:
    print("Right")

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

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

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


import sys
 
stdin = sys.stdin
inf = 1 << 60
mod = 1000000007
 
ni = lambda: int(ns())
nin = lambda y: [ni() for _ in range(y)]
na = lambda: list(map(int, stdin.readline().split()))
nan = lambda y: [na() for _ in range(y)]
nf = lambda: float(ns())
nfn = lambda y: [nf() for _ in range(y)]
nfa = lambda: list(map(float, stdin.readline().split()))
nfan = lambda y: [nfa() for _ in range(y)]
ns = lambda: stdin.readline().rstrip()
nsn = lambda y: [ns() for _ in range(y)]
ncl = lambda y: [list(ns()) for _ in range(y)]
nas = lambda: stdin.readline().split()

A, B, C, D = na()
E = A + B
F = C + D

if E == F:
    print("Balanced")
elif E > F:
    print("Left")
elif E < F:
    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(x) for x in input().split()]

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

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

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

Solution (Python):

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

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

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

Solution (Python):


def main():
    
    
    

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

main()

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):
ABCD=list(map(int,input().split(' ')))
l,r=sum(ABCD[:2]),sum(ABCD[2:])
if l>r:
    print('Left')
elif l==r:
    print('Balanced')
else:
    print('Right')

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

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

if (a+b) < (c+d):
    print('Right')

elif (c+d) < (a+b):
    print('Left')

else :
    print('Balanced')

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

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

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

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

Solution (Python):
w = list(map(int, input().split()))
if sum(w[:2])>sum(w[:-3:-1]):
    print("Left")
elif sum(w[:2])==sum(w[:-3:-1]):
    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):

def Libra(a , b , c , d):

    ans = ""

    if a + b == c + d:
        ans = "Balanced"
    elif a + b > c + d:
        ans = "Left"
    else:
        ans = "Right"
    
    return ans

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

if __name__ == '__main__':
    main()

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())
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)-(A+B<C+D)])

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

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

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 = 'Balanced'
else:
    ans = 'Right'

print(ans)

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

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

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

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