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:
import sys
import os

MOD = 10 ** 9 + 7


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

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


if __name__ == '__main__':
    main()

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

Submission status: Accepted

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

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

Submission status: Accepted

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

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
#abc083 a 
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('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('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:
# Author: cr4zjh0bp
# Created: Thu Mar 12 20:17:33 UTC 2020
import sys
 
stdin = sys.stdin
inf = 1 << 60
mod = 1000000007
 
ni = lambda: int(ns())
nin = lambda y: [ni() for _ in range(y)]
na = lambda: list(map(int, stdin.readline().split()))
nan = lambda y: [na() for _ in range(y)]
nf = lambda: float(ns())
nfn = lambda y: [nf() for _ in range(y)]
nfa = lambda: list(map(float, stdin.readline().split()))
nfan = lambda y: [nfa() for _ in range(y)]
ns = lambda: stdin.readline().rstrip()
nsn = lambda y: [ns() for _ in range(y)]
ncl = lambda y: [list(ns()) for _ in range(y)]
nas = lambda: stdin.readline().split()

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

if E == F:
    print("Balanced")
elif E > F:
    print("Left")
elif E < F:
    print("Right")

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

Submission status: Accepted

Solution code:
# A - Libra
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 = 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:
from sys import stdin

a, b, c, d = [int(x) for x in stdin.readline().rstrip().split()]

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

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

Submission status: Accepted

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

def main():
    #n = int(input())
    #i = list(map(int,input().split()))
    #j = list(map(int,input().split()))

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

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
w = list(map(int, input().split()))
if sum(w[:2])>sum(w[:-3:-1]):
    print("Left")
elif sum(w[:2])==sum(w[:-3:-1]):
    print("Balanced")
else:
    print("Right")

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:
# coding: utf-8
# Your code here!
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:

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

    ans = ""

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

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

if __name__ == '__main__':
    main()

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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

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:
    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())
left = A + B
right = C + D

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

print(ans)

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

Submission status: Accepted

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

A,B,C,D = [int(i) for i in input().rstrip().split()]

L=A+B
R=C+D

print( "Left" if L>R else "Balanced" if L==R else "Right" )

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())
w = (a+b) - (c+d)
if w == 0:
    print("Balanced")
elif w > 0:
    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 = (int(_) for _ in 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:
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("Balanced")
elif a + b < c + d:
  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("Right")
else:
  print("Balanced")

Submission status: Accepted

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

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

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())
x,y = a+b, c+d

if x == y:
    print("Balanced")
elif x > y:
    print("Left")
elif x < y:
    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="Left"
elif l<r:
    ans="Right"
else:
    ans="Balanced"
print(ans)

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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
# 入力 : 数字4つ
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 (a + b) > (c + d):
    print("Left")
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,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')

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

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

Submission status: Accepted

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

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

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:
#!/usr/bin/env python3
# -*- coding: utf-8 -*-


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

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 "Balanced" if L==R else "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("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:
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)

Submission status: Accepted

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

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

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("Right")
elif left>right:
    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 ('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:
"""
author : halo2halo
date : 24, Jan, 2020
"""

import sys
import itertools

# import numpy as np

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

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

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

Submission status: Accepted

Solution code:
#n = int(input())
a,b,c,d = map(int,input().split())
#lst1 = 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, 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")

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

Submission status: Accepted

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

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

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

Submission status: Accepted

Solution code:

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

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/python3
# vim: set fileencoding=utf-8:
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):  # 隣接かつ未探索であれば、stackにpush
            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にpush
            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()