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.



Sample input:
3 8 7 1


Sample output:
Left

Submission status: Accepted

Solution code:
a1,a2,b1,b2 = map(int, input().split())
a = a1+a2
b = b1+b2
print('Left' if a>b else ('Balanced' if a==b else 'Right'))

Submission status: Accepted

Solution code:
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")

Submission status: Accepted

Solution code:
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")

Submission status: Accepted

Solution code:
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')

Submission status: Accepted

Solution code:
aa = list(map(int,input().split()))
bb = ["Left","Right","Balanced"]
a,b,c,d = [i for i in aa]

if a + b > c +d:
    print(bb[0] )
if a + b < c +d:
    print(bb[1] )
if a + b == c +d:
    print(bb[2] )

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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")

Submission status: Accepted

Solution code:
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")

Submission status: Accepted

Solution code:
A=list(map(int,input().split()))
a=sum(A[:2])
b=sum(A[2:])
if a > b:
    print('Left')
elif a < b:
    print('Right')
else:
    print('Balanced')

Submission status: Accepted

Solution code:
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")

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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")

Submission status: Accepted

Solution code:
a, b, c, d = map(int, input().split())
res = (a + b) - (c + d)

if res == 0:
  print("Balanced")
elif res > 0:
  print("Left")
else:
  print("Right")

Submission status: Accepted

Solution code:
def abc():
    a, b, c, d = map(int, input().split())
    l = a + b
    r = c + d

    if l > r:
        print('Left')
        return
    if l < r:
        print('Right')
        return
    print('Balanced')


abc()

Submission status: Accepted

Solution code:
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')

Submission status: Accepted

Solution code:
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")

Submission status: Accepted

Solution code:
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")

Submission status: Accepted

Solution code:
A, B, C, D = [int(x) for x in input().split()]
if A + B < C + D:
  print("Right")
elif A + B > C + D:
  print("Left")
elif A + B == C + D:
  print("Balanced")

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-

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

Submission status: Accepted

Solution code:
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')

Submission status: Accepted

Solution code:
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")

Submission status: Accepted

Solution code:
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')

Submission status: Accepted

Solution code:
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')

Submission status: Accepted

Solution code:
A, B, C, D = [int(x) for x in input().split()]
left = A+B
right = C+D
if left > right:
    print('Left')
elif left < right:
    print('Right')
else:
    print('Balanced')

Submission status: Accepted

Solution code:
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")

Submission status: Accepted

Solution code:
A,B,C,D=input().split()
a=int(A)
b=int(B)
c=int(C)
d=int(D)
x=a+b
y=c+d
if x>y:
  print('Left')
elif x<y:
  print('Right')
else:
  print('Balanced')

Submission status: Accepted

Solution code:
import math

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

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
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')

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
import sys


def solve(A: int, B: int, C: int, D: int):
    if A + B > C + D:
        ret = 'Left'
    elif A + B < C + D:
        ret = 'Right'
    else:
        ret = 'Balanced'
    print(ret)
    return


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    A = int(next(tokens))  # type: int
    B = int(next(tokens))  # type: int
    C = int(next(tokens))  # type: int
    D = int(next(tokens))  # type: int
    solve(A, B, C, D)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
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')

Submission status: Accepted

Solution code:
#
# 　　  ⋀_⋀　 
#　　  (･ω･)  
# .／ Ｕ ∽ Ｕ＼
#  │＊　合　＊│
#  │＊　格　＊│ 
#  │＊　祈　＊│ 
#  │＊　願　＊│ 
#  │＊　　　＊│ 
#      ￣
#
import sys
input=sys.stdin.readline
inf=float('inf')
mod = 10**9+7
def INT_(n): return int(n)-1
def MI(): return map(int,input().split())
def MF(): return map(float, input().split())
def MI_(): return map(INT_,input().split())
def LI(): return list(MI())
def LI_(): return [int(x) - 1 for x in input().split()]
def LF(): return list(MF())
def LIN(n:int): return [input() for _ in range(n)]
def LLIN(n: int): return [LI() for _ in range(n)]
def LLIN_(n: int): return [LI_() for _ in range(n)]
def LLI(): return [list(map(int, l.split() )) for l in input()]
def I(): return int(input())
def F(): return float(input())
def ST(): return input().replace('\n', '')
def main():
    a, b, c, d = MI()
    left = a + b
    right = c + d
    if left > right:
        print("Left")
    elif left < right:
        print("Right")
    else:
        print("Balanced")
if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
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")

Submission status: Accepted

Solution code:
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')

Submission status: Accepted

Solution code:
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")

Submission status: Accepted

Solution code:
A, B, C, D = [int(i) for i in input().split()]
E = A + B - C - D
if E > 0:
    print("Left")
elif E == 0:
    print("Balanced")
else:
    print("Right")

Submission status: Accepted

Solution code:
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")

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
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")

Submission status: Accepted

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

left = A + B
right = C + D

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

Submission status: Accepted

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

ans1 = a+b
ans2 = c+d

if ans1 > ans2:
    print("Left")
elif ans1 < ans2:
    print("Right")
else:
    print("Balanced")

Submission status: Accepted

Solution code:
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')

Submission status: Accepted

Solution code:
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")

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
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')

Submission status: Accepted

Solution code:
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')

Submission status: Accepted

Solution code:
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')

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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")

Submission status: Accepted

Solution code:
from functools import reduce
import math

def main():
    # 文字列の2進数を数値にする
    # '101' → '5'
    # 文字列の頭に'0b'をつけてint()にわたす
    # binary = int('0b'+'101',0)

    # 2進数で立っているbitを数える
    # 101(0x5) → 2
    # cnt_bit = bin(5).count('1')
    
    # N! を求める
    # f = math.factorial(N)

    # N の逆元
    # N_inv = pow(N,MOD-2,MOD)

    # nCr
    # Nの階乗 * rの階乗の逆元 * n-rの階乗の逆元
    
    # 切り捨て
    # 4 // 3
    # 切り上げ
    #-(-4 // 3)
    
    # 初期値用:十分大きい数(100億)
    INF = float("inf")

    # 大きな素数
    MOD = 10**9+7
    
    # 1文字のみを読み込み
    # 入力:2
    # a = input().rstrip()
    # 変数:a='2'
    
    # スペース区切りで標準入力を配列として読み込み
    # 入力:2 4 5 7
    # a, b, c, d = (int(_) for _ in input().split())  
    # 変数:a=2 b=4 c=5 d =7
    
    # 1文字ずつ標準入力を配列として読み込み
    # 入力:2 4 5 7
    # a = list(int(_) for _ in input().split())
    # 変数:a = [2, 4, 5, 7]    

    # 1文字ずつ標準入力を配列として読み込み
    # 入力:2457
    # a = list(int(_) for _ in input())
    # 変数:a = [2, 4, 5, 7]    
    a, b, c, d = (int(_) for _ in input().split())
    if a+b > c+d:        
        print('Left')
    elif a+b == c+d:
        print('Balanced')
    else:
        print('Right')
        
if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
# sys.stdin.readline()
import sys
input = sys.stdin.readline

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)

Submission status: Accepted

Solution code:
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")

Submission status: Accepted

Solution code:
A,B,C,D = [ int(it) for it in input().split() ]

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

Submission status: Accepted

Solution code:
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')

Submission status: Accepted

Solution code:

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


ans = 'Balanced' if a+b==c+d else 'Left' if a+b>c+d else 'Right'

print(ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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'))

Submission status: Accepted

Solution code:
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")

Submission status: Accepted

Solution code:
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")

Submission status: Accepted

Solution code:
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")

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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")

Submission status: Accepted

Solution code:
#!usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
import itertools
sys.setrecursionlimit(10**5)
stdin = sys.stdin
bisect_left = bisect.bisect_left
bisect_right = bisect.bisect_right
def LI(): return list(map(int, stdin.readline().split()))
def LF(): return list(map(float, stdin.readline().split()))
def LI_(): return list(map(lambda x: int(x)-1, stdin.readline().split()))
def II(): return int(stdin.readline())
def IF(): return float(stdin.readline())
def LS(): return list(map(list, stdin.readline().split()))
def S(): return list(stdin.readline().rstrip())
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float('INF')

#A
def A():
    a, b, c, d = LI()
    a += b
    c += d
    ans = ["Left", "Right"]
    if a == c:
        print("Balanced")
        return
    print(ans[a < c])
    return

#B
def B():
    return

#C
def C():
    return

#D
def D():
    return

#E
def E():
    return

#F
def F():
    return

#G
def G():
    return

#H
def H():
    return

#Solve
if __name__ == '__main__':
    A()

Submission status: Accepted

Solution code:
#!/usr/bin/env python3

import math

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:

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

L = sum(l[:2])
R = sum(l[2:])

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys


def input():
    return sys.stdin.readline()[:-1]

# N = int(input())
# A = [int(x) for x in input().split()]
# a, b, c = map(int, input().split())
# name1 = str(input())
# alph = {"A": 1, "B": 2, "C": 3, "D": 4, "E": 5}


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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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')

Submission status: Accepted

Solution code:
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")

Submission status: Accepted

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

Submission status: Accepted

Solution code:
M=[int(i) for i in input().split()]
if M[0]+M[1]<M[2]+M[3]:
    print('Right')
elif M[0]+M[1]>M[2]+M[3]:
    print('Left')
else:
    print('Balanced')

Submission status: Accepted

Solution code:
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")

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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")

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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')

Submission status: Accepted

Solution code:
#天秤
  
a,b,c,d=map(int,input().split())

l=a+b
r=c+d

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

Submission status: Accepted

Solution code:
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")

Submission status: Accepted

Solution code:
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")

Submission status: Accepted

Solution code:
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')

Submission status: Accepted

Solution code:
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")

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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')

Submission status: Accepted

Solution code:
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")

Submission status: Accepted

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


main()

Submission status: Accepted

Solution code:
import sys, os

f = lambda:list(map(int,input().split()))
if 'local' in os.environ :
    sys.stdin = open('./input.txt', 'r')

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

solve()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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')

Submission status: Accepted

Solution code:
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')

Submission status: Accepted

Solution code:
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")

Submission status: Accepted

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

m=a+b
n=c+d

if m>n:
  print("Left")
elif m==n:
  print("Balanced")
else:
  print("Right")

Submission status: Accepted

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

Submission status: Accepted

Solution code:

# スペース区切りの整数の入力
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')

Submission status: Accepted

Solution code:
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")

Submission status: Accepted

Solution code:

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


def submit():
    a, b, c, d = read_input()

    l = a + b
    r = c + d

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


if __name__ == '__main__':
    submit()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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")

Submission status: Accepted

Solution code:
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")

Submission status: Accepted

Solution code:
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')

Submission status: Accepted

Solution code:
a,s,d,f=map(int,input().split())
if a+s>d+f:
  print("Left")
elif a+s==d+f:
  print("Balanced")
else:
  print("Right")

Submission status: Accepted

Solution code:
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')

Submission status: Accepted

Solution code:
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')

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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")

Submission status: Accepted

Solution code:
a = [int(i) for i in input().split()]
l = a[0] + a[1]
r = a[2] + a[3]
if l > r: s = "Left"
elif l < r: s = "Right"
else: s = "Balanced"
print(s)

Submission status: Accepted

Solution code:
a = [int(i) for i in input().split()] 

if sum(a[0:2]) == sum(a[2:4]):
  print("Balanced")
elif sum(a[0:2]) > sum(a[2:4]):
  print("Left")
else:
  print("Right")

Submission status: Accepted

Solution code:
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')

Submission status: Accepted

Solution code:
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')

Submission status: Accepted

Solution code:
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')

Submission status: Accepted

Solution code:
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')

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-

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

Submission status: Accepted

Solution code:
a,b,c,d=map(int,input().split())
a=a+b
c=c+d
print(["Left","Right","Balanced"][(a<=c)+(a==c)])

Submission status: Accepted

Solution code:
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")

Submission status: Accepted

Solution code:
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")

Submission status: Accepted

Solution code:
import functools

import os

INF = float('inf')


def inp():
    return int(input())


def inpf():
    return float(input())


def inps():
    return input()


def inl():
    return list(map(int, input().split()))


def inlf():
    return list(map(float, input().split()))


def inls():
    return input().split()


def inpm(line):
    return [inp() for _ in range(line)]


def inpfm(line):
    return [inpf() for _ in range(line)]


def inpsm(line):
    return [inps() for _ in range(line)]


def inlm(line):
    return [inl() for _ in range(line)]


def inlfm(line):
    return [inlf() for _ in range(line)]


def inlsm(line):
    return [inls() for _ in range(line)]


def debug(fn):
    if not os.getenv('LOCAL'):
        return fn

    @functools.wraps(fn)
    def wrapper(*args, **kwargs):
        print('DEBUG: {}({}) -> '.format(
            fn.__name__,
            ', '.join(
                list(map(str, args)) +
                ['{}={}'.format(k, str(v)) for k, v in kwargs.items()]
            )
        ), end='')
        ret = fn(*args, **kwargs)
        print(ret)
        return ret

    return wrapper


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

Submission status: Accepted

Solution code:
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')

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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')

Submission status: Accepted

Solution code:
# ABC083A - Libra
a, b, c, d = list(map(int, input().rstrip().split()))
if a + b > c + d:
    print("Left")
elif a + b == c + d:
    print("Balanced")
else:
    print("Right")

Submission status: Accepted

Solution code:
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')

Submission status: Accepted

Solution code:
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")

Submission status: Accepted

Solution code:
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')

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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")

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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")

Submission status: Accepted

Solution code:
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")