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

Solution (Python):
def resolve():
    l1, l2, r1, r2 = map(int, input().split())
    lw = l1 + l2
    rw = r1 + r2
    
    ans = ""
    if lw < rw:
        ans = "Right"
    elif lw > rw:
        ans = "Left"
    else:
        ans = "Balanced"
    print(ans)
resolve()

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

Solution (Python):
in_list = input().split(' ')
A = in_list[0]
B = in_list[1]
C = in_list[2]
D = in_list[3]

L = int(A) + int(B)
R = int(C) + int(D)

if L < R:
    print('Right')
elif L > R:
    print('Left')
else:
    print('Balanced')

Solution (Python):
a, b, c, d = map(int, input().split())
left = a+b > c+d
eq = a+b == c+d
if left:
  print('Left')
elif eq:
  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('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("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):
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)

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

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

if __name__ == "__main__":
  resolve()

Solution (Python):
from sys import stdin
nii=lambda:map(int,stdin.readline().split())
lnii=lambda:list(map(int,stdin.readline().splt()))

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

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

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


if __name__ == "__main__":
    solve()

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

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

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

Solution (Python):
import sys
def input(): return sys.stdin.readline().strip()


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

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

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

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

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

Solution (Python):
import sys, os, math, bisect, itertools, collections, heapq, queue

from decimal import Decimal
from collections import defaultdict, deque

sys.setrecursionlimit(10000000)

ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]

iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]

lcm = lambda x, y: (x * y) // math.gcd(x, y)

MOD = 10 ** 9 + 7
MAX = float('inf')


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

    a, b, c, d = il()
    print('Right' if a + b < c + d else 'Balanced' if a + b == c + d else 'Left')


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

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

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

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

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

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

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

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

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

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

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

Solution (Python):


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

y = a + b 
z = c + d 

if y==z:
    print("Balanced")
elif y>z:
    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):
import sys
input = sys.stdin.readline

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

Solution (Python):

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


L = sum(ABCD[:2])
R = sum(ABCD[2:])
if L == R:
    print("Balanced")
elif L > R:
    print("Left")
else:
    print("Right")

Solution (Python):
import sys
import math
import itertools
import collections
import heapq
import re
import numpy as np

rr = lambda: sys.stdin.readline().rstrip()
rs = lambda: sys.stdin.readline().split()
ri = lambda: int(sys.stdin.readline())
rm = lambda: map(int, sys.stdin.readline().split())
rl = lambda: list(map(int, sys.stdin.readline().split()))
inf = float('inf')
mod = 10**9 + 7


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

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

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

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

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

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

Solution (Python):
a,b,c,d=[int(i) for i in input().split()]

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

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

Solution (Python):










import sys

def input(): return sys.stdin.readline().rstrip()
def iIn(): return int(input())
def iInM(): return map(int, input().split())
def iInM1(): return map(int1, input().split())
def iInLH(): return list(map(int, input().split()))
def iInLH1(): return list(map(int1, input().split()))
def iInLV(n): return [iIn() for _ in range(n)]
def iInLV1(n): return [iIn()-1 for _ in range(n)]
def iInLD(n): return [iInLH() for _ in range(n)]
def iInLD1(n): return [iInLH1() for _ in range(n)]
def sInLH(): return list(input().split())
def sInLV(n): return [input().rstrip('\n') for _ in range(n)]
def sInLD(n): return [sInLH() for _ in range(n)]

def OutH(lst, deli=' '): print(deli.join(map(str, lst)))
def OutV(lst): print('\n'.join(map(str, lst)))

sys.setrecursionlimit(10 ** 6)

int1 = lambda x: int(x) - 1

INF = int(1e9)
MOD = 1000000007
dx = (-1, 0, 1, 0)
dy = (0, -1, 0, 1)


A, B, C, D = iInM()

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

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

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

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

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

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

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

if not (1 <= A <= 10 and 1 <= B <= 10 and 1 <= C <= 10 and 1 <= D <= 10):
    sys.exit()

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

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
def s(): return input()
def i(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
sys.setrecursionlimit(10 ** 9)
INF = 10**9
mod = 10**9+7

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

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

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

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

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

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

Solution (Python):
import sys
sys.setrecursionlimit(10000000)
MOD = 10 ** 9 + 7
INF = 10 ** 15

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

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

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

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

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):
def actual(a, b, c, d):
    L, R = a + b, c + d

    if L > R:
        return 'Left'
    if L < R:
        return 'Right'

    return 'Balanced'

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

print(actual(a, b, c, d))

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

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

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

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());print('RLiegfhtt'[a+b>c+d::2]if a+b!=c+d else'Balanced')

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

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

x = a+b
y = c+d

if x > y:
    print("Left")

elif x < y:
    print("Right")

else:
    print("Balanced")

Solution (Python):
A,B,C,D=map(int,input().split())
if A+B>C+D:
  print("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):
import sys
input = lambda: sys.stdin.readline().rstrip()

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

Solution (Python):
import bisect,collections,copy,heapq,itertools,math,string
import sys
def S(): return sys.stdin.readline().rstrip()
def M(): return map(int,sys.stdin.readline().rstrip().split())
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LS(): return list(sys.stdin.readline().rstrip().split())
a, b, c, d = M()
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('RLiegfhtt'[a+b>c+d::2] 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 = 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):
import sys
import heapq, math
from itertools import zip_longest, permutations, combinations, combinations_with_replacement
from itertools import accumulate, dropwhile, takewhile, groupby
from functools import lru_cache
from copy import deepcopy

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

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

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

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

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

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

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

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

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

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

if L > R:
    print('Left')
elif L < R:
    print('Right')
else:
    print('Balanced')

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

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

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


import sys






























def main():
    mod = 1000000007                
    inf = float('inf')              
    
    sys.setrecursionlimit(10**6)    
    def input(): return sys.stdin.readline().rstrip()
    def ii():    return int(input())
    def mi():    return map(int, input().split())
    def mi_0():  return map(lambda x: int(x)-1, input().split())
    def lmi():   return list(map(int, input().split()))
    def lmi_0(): return list(map(lambda x: int(x)-1, input().split()))
    def li():    return list(input())
    
    
    a, b, c, d = mi()
    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('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('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())
l, r = a + b, c + d
print("Left" if l > r else ("Balanced" if l == r else "Right"))