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 I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
mod=10**9+7

a,b,c,d=MI()

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())
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())
left = a + b
right = c + d
if left < right:
    print("Right")
elif left == right:
    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())
x,y = a+b, c+d

if x == y:
    print("Balanced")
elif x > y:
    print("Left")
elif x < y:
    print("Right")

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

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

if w1<w2:
  print("Right")
elif w1==w2:
  print("Balanced")
else:
  print("Left")

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

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

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

Solution (Python):
def main():
    weights = list(map(int, input().split()))
    if sum(weights[:2]) > sum(weights[2:]):
        print("Left")
    elif sum(weights[:2]) == sum(weights[2:]):
        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('Balanced')
else:
  print('Right')

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

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

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

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

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

Solution (Python):

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


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

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

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

left = a + b
right = c + d

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

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




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


if __name__ == "__main__":
    main()

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

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

print(ans)

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

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

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

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

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

Solution (Python):
"""
author : halo2halo
date : 24, Jan, 2020
"""

import sys
import itertools



read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

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

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

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

Solution (Python):

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


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

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

L = A + B
R = C + D

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

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

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

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

l = a + b
r = c + d

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

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

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

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

Solution (Python):

import numpy as np

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


import sys
input = sys.stdin.readline

"""
H = int(input())
h = [int(ele) for ele in input().split()]
h = [0] + h
"""


def main():
    ans = "Balanced"
    A, B, C, D = map(int, input().split())
    L = A + B
    R = C + D
    if L < R:
        ans = "Right"
    elif L > R:
        ans = "Left"

    print(ans)


def bfs(queue):
    global yet, graph
    if len(queue) == 0:
        return
    yet.remove(queue[-1])

    for i, adjacency in enumerate(graph[queue[-1]]):
        if adjacency == 1 and (i in yet) and (i not in queue):  
            queue.appendleft(i)
    else:
        queue.pop()
        bfs(queue)


def dfs(stack):
    global yet, graph
    yet.remove(stack[-1])

    for i, adjacency in enumerate(graph[stack[-1]]):
        if adjacency == 1 and i in yet:  
            stack.append(i)
            dfs(stack)
    else:
        stack.pop()


def make_divisors(n):
    divisors = []
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.append(i)
        if i != n // i:
            divisors.append(n//i)
    return divisors


class Node():

    def __init__(self):
        self.idx = None
        self.left = None
        self.right = None
        self.parent = None
        return

    def pre_order(self):
        global pre_order_str
        pre_order_str += str(self.idx) + " "
        if self.left:
            self.left.pre_order()

        if self.right:
            self.right.pre_order()

    def in_order(self):
        global in_order_str

        if self.left:
            self.left.in_order()

        in_order_str += str(self.idx) + " "

        if self.right:
            self.right.in_order()

    def post_order(self):
        global post_order_str
        if self.left:
            self.left.post_order()

        if self.right:
            self.right.post_order()

        post_order_str += str(self.idx) + " "


class HeapHelper():
    """HeapContrler.
    完全二分木を二分ヒープで表現した配列 A に対して、
    HeapHelper.parent(idx) とするとそのノードの親の添字を返す
    存在しない場合は Falseを返す

    Returns:
        [type] -- [description]
    """

    def __init__(self):
        return

    @staticmethod
    def parent(i):
        if i == 1:
            return False

        return int(i/2)

    @staticmethod
    def left(i):
        l_idx = 2*i
        if H < l_idx:
            return False

        return l_idx

    @staticmethod
    def right(i):
        r_idx = 2*i + 1
        if H < r_idx:
            return False

        return r_idx


if __name__ == "__main__":
    main()

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

if __name__ == '__main__':
    main()

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

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

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

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):
num = input().split()
num_i = [int(s) for s in num]

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

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

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

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

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

A = x[0]
B = x[1]
C = x[2]
D = x[3]

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

Solution (Python):
import sys
input = sys.stdin.readline
A, B, C, D = map(int,input().split())
AB = A+B
CD = C+D
if AB >= CD:
    if AB > CD:
        print("Left")
    else:
        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):
import math
import queue
import bisect
import heapq
import time
import itertools

mod = int(1e9+7)

def swap(a,b):
    return (b,a)

def gcd(a,b): 
    if (a<b):
        a,b = swap(a,b)
    if (b==0):
        return a
    else:
        return gcd(b,a%b)

def lcm(a,b): 
    return a/gcd(a,b)*b

def divisors(a): 
    divisors = []
    for i in range(1,int(a**0.5)+1):
        if a%i==0:
            divisors.append(i)
            if i!=a//i:
                divisors.append(a//i)
    return divisors

def is_prime(a): 
    if a<2:
        return False
    elif a==2:
        return True
    elif a%2==0:
        return False
    sqrt_num = int(a**0.5)
    for i in range(3,sqrt_num+1,2):
        if a%i==0:
            return False
    return True

def prime_num(a): 
    pn = [2]
    for i in range(3,int(a**0.5),2):
        prime = True
        for j in pn:
            if i%j==0:
                prime = False
                break
        if prime:
            pn.append(i)
    return pn

def prime_fact(a): 
    sqrt = math.sqrt(a)
    res = []
    i = 2
    if is_prime(a):
        res.append(a)
    else:
        while a!=1:
            while a%i==0:
                res.append(i)
                a //= i
            i += 1
    return res

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

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

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

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

left = a+b
right = c+d

if left < right:
  print("Right")
elif left > right:
  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):
import sys
input = sys.stdin.readline
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(lambda x: int(x), input().split())

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

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

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

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

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

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

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

print(ans)

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

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

Solution (Python):

import sys


def main(argv=sys.argv):
  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')
    
    
  return 0


if __name__ == '__main__':
  sys.exit(main())

Solution (Python):

import sys


def main(argv=sys.argv):

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

    return 0


if __name__ == '__main__':
    sys.exit(main())

Solution (Python):

from heapq import heappush, heappop, heapify
from collections import deque, defaultdict, Counter
import itertools
from itertools import permutations, combinations
import sys
import bisect
import string
import math
import time
from fractions import gcd



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


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


def LI(): return [int(i) for i in input().split()]


def LI_(): return [int(i)-1 for i in input().split()]


def StoI(): return [ord(i)-97 for i in input()]


def ItoS(nn): return chr(nn+97)


def input(): return sys.stdin.readline().rstrip()


def show(*inp, end='\n'):
    if show_flg:
        print(*inp, end=end)


YN = ['Yes', 'No']
MOD = 10**9+7
inf = float('inf')
IINF = 10**19
l_alp = string.ascii_lowercase
u_alp = string.ascii_uppercase
ts = time.time()
sys.setrecursionlimit(10**6)



show_flg = True


def main():
    A, B, C, D = MI()
    left = A + B
    right = C + D

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

Solution (Python):
import sys

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

def main():
    l = a + b
    r = c + d
    if l > r:
        return 'Left'
    elif l == r:
        return 'Balanced'
    else:
        return 'Right'

if __name__ == '__main__':
    ans = main()
    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())

ans="Balanced"

if a+b>c+d:
    ans="Left"
elif a+b<c+d:
    ans="Right"

print(ans)

"""


3 8 7 1

Left

3 4 5 2

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):
from sys import stdin


def fetch_one_line():
    return stdin.readline().rstrip()


def fetch_int_input():
    return [int(s) for s in fetch_one_line().split()]


def fetch_inputs(times):
    return [fetch_one_line() for _ in range(times)]


def fetch_int_inputs(times):
    return [[int(s) for s in fetch_one_line()] for _ in range(times)]


answers = "Left Balanced Right".split()
A, B, C, D = fetch_int_input()

left = A + B
right = C + D
if left > right:
    id = 0
elif left < right:
    id = 2
else:
    id = 1

print(answers[id])

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

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

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

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

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

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

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

else:
    print('Right')

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

Solution (Python):
import math

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 = list(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

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

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

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

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

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