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:
abcd=input().split()
a=int(abcd[0])
b=int(abcd[1])
c=int(abcd[2])
d=int(abcd[3])
if a+b==c+d:
  print('Balanced')
else:
    if 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")
if(a+b)==(c+d):
    print("Balanced")
elif(a+b)<(c+d):
    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')
if A + B > C + D:
  print('Left')
if A + B == C + D:
  print('Balanced')

Submission status: Accepted

Solution code:
A,B,C,D = tuple(int(num) for num in input().split())

left = A + B
right = C + D

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
#!/usr/bin/python3

import sys
# input = sys.stdin.readline
sys.setrecursionlimit(100000)
INF = float('inf')
MOD = 10**9+7
EPS = 10**-7

#N = int(input())
#A = [int(x) for x in input().split()]
#V = [[0] * 100 for _ in range(100)]

A,B,C,D = [int(x) for x in 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())
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
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())
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,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())

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

Submission status: Accepted

Solution code:
# A
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=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:
l = map(int, raw_input().split())

if l[0]+l[1] > l[2]+l[3]:
  print('Left')
elif l[0]+l[1] == l[2]+l[3]:
  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 left < right:
  print("Right")
else:
  print("Balanced")

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
A, B, C, D = tuple(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")
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())
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())

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

Submission status: Accepted

Solution code:
def slove():
    import sys
    input = sys.stdin.readline
    a, b, c, d = list(map(int, input().rstrip('\n').split()))
    ab = a + b
    cd = c + d
    if ab > cd:
        print("Left")
    elif ab < cd:
        print("Right")
    else:
        print("Balanced")


if __name__ == '__main__':
    slove()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a = list(map(int,input().split()))
A=a[0]
B=a[1]
C=a[2]
D=a[3]

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(s) for s in input().split()]
x=a+b-c-d
if x>0:
  print("Left")
elif x==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('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('Left' if A+B > C+D else 'Balanced' if A+B == C+D else 'Right')

Submission status: Accepted

Solution code:
INT = lambda: int(input())
INTM = lambda: map(int,input().split())
STRM = lambda: map(str,input().split())
STR = lambda: str(input())
LIST = lambda: list(map(int,input().split()))
LISTS = lambda: list(map(str,input().split()))
def do():
    a,b,c,d=INTM()
    if (a+b)>(c+d):
        print('Left')
    elif (a+b)==(c+d):
        print('Balanced')
    else:
        print('Right')
if __name__ == '__main__':
    do()

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

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('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("Right")
else:
    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:
def aa083():
    a,b, c,d = list(map(int, input().split()))
    l = a + b
    r = c + d

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

aa083()

Submission status: Accepted

Solution code:
import sys

input = sys.stdin.readline


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


if __name__ == "__main__":
    main()

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())
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=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('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")
elif l<r:
  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("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
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())

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

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("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 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('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

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

if A+B==C+D:
  print('Balanced')
elif A+B>C+D:
  print('Left')
elif A+B<C+D:
  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:
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:
# ABC083 A - Libra
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 = 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('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("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('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:
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())
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())
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')
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())
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())

weight_left = A + B
weight_right = C + D

if weight_left > weight_right:
    print('Left')
elif weight_left < weight_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 = map(int,input().split())
print(['Balanced', 'Left', 'Right'][A+B>C+D or -(A+B<C+D)])

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()))
l=a+b
r=c+d
if(l>r):
  print("Left")
  exit()
if(l<r):
  print("Right")
  exit()
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:
import sys

if sys.platform =='ios':
    sys.stdin=open('input_file.txt')
    
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())
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")
elif A+B > C+D:
    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 '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")
elif (a + b) < (c + d):
    print("Right")
else:
    print("Left")

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

X = A + B
Y = C + D

if X > Y :
    print('Left')
elif X == Y:
    print('Balanced')
elif X < Y:
    print('Right')

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 = [int(i) for i in input().split()]

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

Submission status: Accepted

Solution code:
s=list(input().split())
a=int(s[0])
b=int(s[1])
c=int(s[2])
d=int(s[3])
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('Balanced' if a+b==c+d else 'Right' if a+b<c+d else 'Left')

Submission status: Accepted

Solution code:
def main():
	linie = input()
	vector = [int(x) for x in linie.split()]	
	if vector[0] + vector[1] > vector[2] + vector[3]:
		print("Left")
	if vector[0] + vector[1] == vector[2] + vector[3]:
		print("Balanced")
	if vector[0] + vector[1] < vector[2] + vector[3]:
		print("Right")
 
 
if __name__ == "__main__":
	main()

Submission status: Accepted

Solution code:
A = list(map(int, input().split()))
if A[0] + A[1] == A[2] + A[3]:
  print('Balanced')
  exit()
elif A[0] + A[1] > A[2] + A[3]:
  print('Left')
  exit()
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())
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())

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

Submission status: Accepted

Solution code:
a, b, c, d = map(int, input().split())
a = a + b
b = c + d
if a < b:
    print("Right")
elif a > b:
    print("Left")
elif a == b:
    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:
#coding:utf-8
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());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")
elif l < r:
  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:
S = input().split()
A, B, C, D = int(S[0]), int(S[1]), int(S[2]), int(S[3])
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

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

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

Submission status: Accepted

Solution code:
a,b,c,d=map(int,input().split());e=a+b-c-d;print("LBReaiflgtah nt c  e  d"[(e<0)+(e<=0)::3])

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

Submission status: Accepted

Solution code:
a = [int(_) for _ in input().split()]
if len(a) == 4 and all(1 <= item <= 10 for item in a):
    if a[0] + a[1] > a[2] + a[3]:
        print('Left')
    elif a[0] + a[1] == a[2] + a[3]:
        print('Balanced')
    else:
        print('Right')
else:
    print('hoge!')

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:
num = input().split()
a, b, c, d = int(num[0]),int(num[1]),int(num[2]),int(num[3])

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

Submission status: Accepted

Solution code:
import sys
from statistics import *
from collections import *
from operator import itemgetter

stdin = sys.stdin

ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline()

li = na()
l = sum(li[:2])
r = sum(li[2:])
if l == r:
    print('Balanced')
elif r > l:
    print('Right')
else:
    print('Left')

Submission status: Accepted

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


if __name__ == "__main__":
    resolve()

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())
A = ["Left", "Balanced", "Right"]
print(A[int((c+d) > (a+b)) - int((a+b) > (c+d)) + 1])

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:
import sys
input = sys.stdin.readline
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:


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

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
a,b,c,d = [int(j) for j in 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())
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())
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())

left = a + b
right = c + d

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

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

Submission status: Accepted

Solution code:
if __name__ == '__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')

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