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

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("Right")
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:
import sys
import itertools
sys.setrecursionlimit(1000000000)
from heapq import heapify,heappop,heappush,heappushpop

import collections

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import accumulate, permutations, combinations, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

A, B, C, D = MAP()
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())
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("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:
import sys
## io ##
def IS(): return sys.stdin.readline().rstrip()
def II(): return int(IS())
def MII(): return list(map(int, IS().split()))
def MIIZ(): return list(map(lambda x: x-1, MII()))
## dp ##
INIT_VAL = 0
def DD2(d1,d2): return [[INIT_VAL]*d2 for _ in range(d1)]
def DD3(d1,d2,d3): return [DD2(d2,d3) for _ in range(d1)]
## math ##
MOD=10**9+7
def divc(x,y): return -(-x//y)
def divf(x,y): return x//y
def gcd(x,y):
    while y: x,y = y,x%y
    return x
def lcm(x,y): return x*y//gcd(x,y)
def get_primes(MAX_NUM=10**3):
    """Return a list of prime numbers"""
    is_prime = [True] * MAX_NUM
    is_prime[0] = False
    is_prime[1] = False
    primes = []
    for i in range(MAX_NUM):
        if is_prime[i]:
            primes.append(i)
            for j in range(2*i, MAX_NUM, i):
                is_prime[j] = False
    return primes
## libs ##
from itertools import accumulate as acc
from collections import deque, Counter
from heapq import heapify, heappop, heappush
from bisect import bisect_left

#======================================================#

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

if __name__ == '__main__':
    main()

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

Submission status: Accepted

Solution code:
# ABC083A

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
#from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
from math import floor, ceil,pi
#from operator import itemgetter
from copy import deepcopy
def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
def LI2(): return [int(input()) for i in range(n)]
def MXI(): return [LI()for i in range(n)]
inf = 10**17
mod = 10**9 + 7

a,b,c,d=MI()
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")
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())
e=A+B-C-D
print("Balanced")if e==0else print(["","Left","Right"][int(e/abs(e))])

Submission status: Accepted

Solution code:
A,B,C,D=map(int,input().split())
e=A+B-C-D
print("Balanced")if e==0 else print(["","Left","Right"][int(e/abs(e))])

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:
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())
apple = A + B
dell = C + D
if dell > apple:
    print("Right")
elif dell < apple:
    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('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('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 = 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=list(map(int,input().split()))
x=a+b
y=c+d
if x>y:
  print("Left")
elif x<y:
  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 right > left:
    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())
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=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("Left")
if a+b < c+d:
  print("Right")
if a+b == c+d:
  print("Balanced")

Submission status: Accepted

Solution code:

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


if '__main__' == __name__:
    resolve()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def main():
    A, B, C, D = map(int, input().split())
    if (A + B) > (C + D):
        print("Left")
    elif (A + B) < (C + D):
        print("Right")
    else:
        print("Balanced")
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:
a,b,c,d = [int(x) for x in input().split()]
l = a+b
r = c+d
if r > l:
  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("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:
from sys import stdin
import math

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:
x=list(map(int,input().split()))
l=x[0]+x[1]
r=x[2]+x[3]
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('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("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:
icase=0    
if icase==0:
    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")
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())
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 = 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;
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())
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())
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('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 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())
x = a + b - c - d
if x > 0:
    print('Left')
elif x < 0:
    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=input().split()
A=int(A)
B=int(B)
C=int(C)
D=int(D)

sumL=A+B
sumR=C+D


if sumL>sumR:
    print('Left')
elif sumL<sumR:
    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('Balanced')
else:
  print('Left')

Submission status: Accepted

Solution code:
a = list(map(int,input().split()))
x = a[0] + a[1]
y = a[2] + a[3]
if x > y:
    print("Left")
elif x == y:
    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())
if a+b == c+d:
    print("Balanced")
if a+b < c+d:
    print("Right")
if a+b > c+d:
    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())
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(["RLiegfhtt"[a+b > c+d::2], "Balanced"][a+b == c+d])

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

Submission status: Accepted

Solution code:
import sys
stdin = sys.stdin

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

a,b,c,d = na()
e = a+b
f = c+d

print('Left' if e > f else 'Balanced' if e == f 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('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:
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())

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

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

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

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

Submission status: Accepted

Solution code:
import sys

a, b, c, d = map(int, sys.stdin.readline().split())
l = a + b
r = c + d

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

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

Submission status: Accepted

Solution code:
# ABC 083: A – Libra
a, b, c, d = [int(s) for s 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:
import sys
import copy
import math
import bisect
import pprint
import bisect
from functools import reduce
from copy import deepcopy
from collections import deque

if __name__ == '__main__':
    a = [int(i) for i in input().split()]

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

Submission status: Accepted

Solution code:
def ii():return int(input())
def iim():return map(int,input().split())
def iil():return list(map(int,input().split()))
a,b,c,d = iim()
if a+b < c+d:
    print('Right')
elif a+b > c+d:
    print('Left')
else:
    print('Balanced')

Submission status: Accepted

Solution code:
t = [int(v) for v in input().split(' ')]
n = t[0] + t[1]
n2 = t[2] + t[3]
 
if n > n2:
  print('Left')
elif n < n2:
  print('Right')
elif n == n2:
  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('Balanced') if (A + B) == (C + D) else print('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('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("Left")
elif A<C:
  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 = list(map(int, input().split()))
l = a[0] + a[1]
r = a[2] + a[3]
if l > r:
    print("Left")
elif l == r:
    print("Balanced")
else:
    print("Right")

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'*(A+B-C-D==0)or'RLiegfhtt'[A+B-C-D>0::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("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("Right")
elif L == R:
  print("Balanced")
else:
  print("Left")

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:
import math


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('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=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:
l = list(map(int,input().split()))
if l[0]+l[1] > l[2]+l[3]:
    print("Left")
elif l[0]+l[1] < l[2]+l[3]:
    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:
# | Its_Rashid | #
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
from math import sqrt
from collections import Counter

input = sys.stdin.readline


def I():
    return int(input())


def MI():
    return map(int, input().split())


def LI():
    return list(MI())


inf = float("inf")
mod = 10 ** 9 + 7


def main():
    a, b, c, d = MI()

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


if __name__ == "__main__":
    main()