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-----
3 8 7 1

-----Sample Output-----
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.

Difficulty: introductory

Starter code:

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

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

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

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

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

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

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

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

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


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

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

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

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


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


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


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

# 上皿天秤は、左の皿に乗っているおもりの重さの合計を L とし、
# 右の皿に乗っているおもりの重さの合計を R としたとき、
# L > R なら左に傾き、 L = R なら釣り合い、
# L < R なら右に傾きます。
#
# 高橋君は、上皿天秤の左の皿に重さ A のおもりと重さ B のおもりを、
# 右の皿に重さ C のおもりと重さ D のおもりを置きました。
#
# 上皿天秤が左に傾くなら Left を、
# 釣り合うなら Balanced を、
# 右に傾くなら Right を出力してください。

# 制約
# 1 ≦ A, B, C, D ≦ 10
# 入力はすべて整数である

# 標準入力から A, B, C ,D の値を取得する
a, b, c, d = list(map(int, input().split()))

# 上皿天秤の状態を判定し、結果を出力する
result = "ret"

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

print(result)


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)

left1, left2, right1, right2 = map(int, input().split())
if right1 + right2 > left1 + left2:
    print('Right')
elif right1 + right2 < left1 + left2:
    print('Left')
else:
    print('Balanced')

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

# 入力
A, B, C, D = list(map(int, input().split()))

# 出力
if 1 <= A and B and C and D <= 10:
    if A + B == C + D:
        print('Balanced')
    elif A + B > C + D:
        print('Left')
    elif A + B < C + D:
        print('Right')


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

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

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

# 上皿天秤は、左の皿に乗っているおもりの重さの合計を L とし、
# 右の皿に乗っているおもりの重さの合計を R としたとき、
# L > R なら左に傾き、 L = R なら釣り合い、
# L < R なら右に傾きます。
#
# 高橋君は、上皿天秤の左の皿に重さ A のおもりと重さ B のおもりを、
# 右の皿に重さ C のおもりと重さ D のおもりを置きました。
#
# 上皿天秤が左に傾くなら Left を、
# 釣り合うなら Balanced を、
# 右に傾くなら Right を出力してください。

# 制約
# 1 ≦ A, B, C, D ≦ 10
# 入力はすべて整数である

# 標準入力から A, B, C ,D の値を取得する
a, b, c, d = list(map(int, input().split()))

# 上皿天秤の状態を判定し、結果を出力する
result = "ret"

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

print(result)


# 083_a
A,B,C,D=list(map(int,input().split()))
if (1<=A and A<=10)and(1<=B and B<=10)and(1<=C and C<=10)and(1<=D and D<=10):
    L=A+B
    R=C+D
    if L>R:
        print('Left')
    elif L==R:
        print('Balanced')
    elif L<R:
        print('Right')


S = input()
S_list = S.split()

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

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

# A - Libra
# https://atcoder.jp/contests/abc083/tasks/abc083_a

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

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

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

print(result)


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


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

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

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

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

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

import math
# s=int(input())
# b=input()
# c=[]
# for i in range(b):
#     c.append(a[i])
a = list(map(int,input().split()))
#b = list(map(int,input().split()))

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

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


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

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

a, b, c, d = list(map(int, input().split()))
left = a+b
right = c+d
print((['Balanced', 'Left', 'Right'][left > right or -(right > left)]))



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

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

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

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

# 各錘の重量を取得
A,B,C,D = map(int,input().split())

# 左と右の皿の重さを計算
LWeight = A + B
RWeight = C + D

# 比較結果にもどづいて各メッセージを出力
if LWeight > RWeight:
    print("Left")
elif LWeight < RWeight:
    print("Right")
else:
    print("Balanced")

#
# abc083 a
#
import sys
from io import StringIO
import unittest


class TestClass(unittest.TestCase):
    def assertIO(self, input, output):
        stdout, stdin = sys.stdout, sys.stdin
        sys.stdout, sys.stdin = StringIO(), StringIO(input)
        resolve()
        sys.stdout.seek(0)
        out = sys.stdout.read()[:-1]
        sys.stdout, sys.stdin = stdout, stdin
        self.assertEqual(out, output)

    def test_入力例_1(self):
        input = """3 8 7 1"""
        output = """Left"""
        self.assertIO(input, output)

    def test_入力例_2(self):
        input = """3 4 5 2"""
        output = """Balanced"""
        self.assertIO(input, output)

    def test_入力例_3(self):
        input = """1 7 6 4"""
        output = """Right"""
        self.assertIO(input, output)


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


def __starting_point():
    # unittest.main()
    resolve()

__starting_point()

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

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

# A - Libra

# 天秤の左の皿におもりA,Bを、右の皿におもりB,Dを載せた場合、
# 天秤がどちらに傾くかを出力する


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

left_dish = A + B
right_dish = C + D

if left_dish > right_dish:
    print('Left')
elif left_dish < right_dish:
    print('Right')
elif left_dish == right_dish:
    print('Balanced')


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

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

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


#   AtCoder abc083 a
#   ストレッチ課題

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

#   判定
diff = (a + b) - (c + d)
if diff == 0:
    print("Balanced")
elif diff > 0:
    print("Left")
else:
    print("Right")


left_a, left_b, right_a, right_b = list(map(int, input().split()))

left_weight = left_a + left_b
right_weight = right_a + right_b

if left_weight == right_weight:
    print('Balanced')
elif left_weight > right_weight:
    print('Left')
elif right_weight > left_weight:
    print('Right')


def mapt(fn, *args):
    return tuple(map(fn, *args))


def Input():
    return mapt(int, input().split(" "))


def main():
    a, b, c, d = Input()
    x, y = a + b, c + d
    
    if   x > y: print("Left")
    elif x < y: print("Right")
    else:       print("Balanced")


main()

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

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

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

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

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

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

def __starting_point():
    resolve()

__starting_point()

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

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

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

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


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

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

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

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


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

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



a = input().split()
a = [int(j) for j in a]
a.append(a[:2])
a.append(a[2:4])
if sum(a[4]) > sum(a[5]):
    print("Left")
if sum(a[4]) == sum(a[5]):
    print("Balanced")
if sum(a[4]) < sum(a[5]):
    print("Right")

# 入力
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')

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

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

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

import sys

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

# A,B,C,Dのおもりの重さを整数で入力
A,B,C,D = map(int,input().split())
if A + B > C + D:
# 左の皿（A+B）の方が重いならLeft、同じならBalanced、左の皿（C+D）が重いならRightを出力
    print("Left")
elif A + B == C + D:
    print("Balanced")
else:
    print("Right")

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

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

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

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

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

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

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

# 4つのおもりで天秤の重さ比べ

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

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

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


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

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

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

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

lst = input().split()

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

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

x,y,z,w =map(int,input().split())
print("Left" if x+y>z+w else "Right" if x+y<z+w else "Balanced")

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

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

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

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

# 083a

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


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

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

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

import bisect,collections,copy,heapq,itertools,math,string
import sys
def I():
    #1 line 1 int
     return int(sys.stdin.readline().rstrip())
def LI():
    #1 line n int
     return list(map(int,sys.stdin.readline().rstrip().split()))
def S():
    #1 line 1 string
     return sys.stdin.readline().rstrip()
def LS():
    #1 line n strings
     return list(sys.stdin.readline().rstrip().split())

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

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

#!/usr/bin/env python3
import sys
sys.setrecursionlimit(10**6)

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

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