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:
#!usr/bim/python
#! -*- coding: utf-8 -*-

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

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

Submission status: Accepted

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

L = int(A) + int(B)
R = int(C) + int(D)

if L > R:
    print("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 = 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:
# -*- coding: utf-8 -*-
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 = [int(x) for x 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")
if a + b < c + d:
    print("Right")
if a + b == c + d:
    print("Balanced")

Submission status: Accepted

Solution code:
print(['Right', 'Balanced', 'Left'][max(min(sum([-x if i > 1 else x for i, x in enumerate([int(s) for s in input().split()])]), 1),-1) + 1])

Submission status: Accepted

Solution code:
s = input()
l = s.split()   #スペースで区切る 

A = int(l[0])
B = int(l[1])
C = int(l[2])
D = int(l[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())

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

Submission status: Accepted

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

args = input().split(' ')
left = int(args[0]) + int(args[1])
right = int(args[2]) + int(args[3])
if left > right:
    print('Left')
elif left < right:
    print('Right')
else:
    print('Balanced')

Submission status: Accepted

Solution code:
# A - Libra
# coding: utf-8
A, B, C, D = map(int, raw_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 = [int(i) for i in input().split()]
  
Left = A + B
Right = C + D
if Left > Right :
        print('Left')
elif Left == Right :
        print('Balanced')
else :
        print('Right')

Submission status: Accepted

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

if a > c : print('Left')
elif a == c : print('Balanced')
else : print('Right')

Submission status: Accepted

Solution code:
# coding: utf-8

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

# main
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:
nums = list(map(int, input().split()))

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math
import itertools
import heapq
from sys import stdin, stdout, setrecursionlimit
from bisect import bisect, bisect_left, bisect_right
from collections import defaultdict, deque


# d = defaultdict(lambda: 0)
# setrecursionlimit(10**7)
# inf = float("inf")


##### stdin ####
def LM(t, r): return list(map(t, r))
def R(): return stdin.readline()
def RS(): return R().split()
def I(): return int(R())
def F(): return float(R())
def LI(): return LM(int,RS())
def LF(): return LM(float,RS())
def ONE_SL(): return list(input())
def ONE_IL(): return LM(int, ONE_SL())
def ALL_I(): return map(int, stdin)
def ALL_IL(): return LM(int,stdin)

##### tools #####
def ap(f): return f.append
def pll(li): print('\n'.join(LM(str,li)))
def pljoin(li, s): print(s.join(li))

##### main #####



def main():
	a,b, c,d = LI()
	if a+b == c+d:
		print("Balanced")
	else:
		print("Left" if a+b>c+d else "Right")

if __name__ == '__main__':
	main()

Submission status: Accepted

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

Submission status: Accepted

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

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:
    print("Left")
else:
    if 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:
l=input().split()
ll=len(l)
i=0
for i in range(ll):
    l[i]=int(l[i])
a=l[0]+l[1]
b=l[2]+l[3]
if a>b:
    print("Left")
elif a<b:
    print("Right")
else:
    print("Balanced")

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def LI(): return [int(x) for x in input().split(" ")]
def LS(): return [str(x) for x in input().split(" ")]
def ItoS(L): return [int(x) for x in L]
def StoI(L): return [str(x) for x in L]


def solve():
    a, b, c, d = LI()
    l, r = a + b, c + d
    if l > r:
        print("Left")
    elif r > l:
        print("Right")
    else:
        print("Balanced")


solve()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools

sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**15
mod = 10**9+7

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)


def main():
    a,b,c,d = LI()
    a += b
    c += d
    if a>c:
        return 'Left'
    if a<c:
        return 'Right'

    return 'Balanced'



print(main())

Submission status: Accepted

Solution code:
# coding: utf-8

a, b, c, d = map(int, input().rstrip().split(" "))
hidari = a + b
migi = c + d

if hidari > migi:
    print("Left")
elif hidari < migi:
    print("Right")
else:
    print("Balanced")

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
# coding=utf-8

import sys

a, b, c, d = sys.stdin.readline().split(" ")
a = int(a)
b = int(b)
c = int(c)
d = int(d)

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

Submission status: Accepted

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

if left < right:
    print("Right")
elif right < left:
    print("Left")
else:
    print("Balanced")

Submission status: Accepted

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

Submission status: Accepted

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

if A+B > C+D:
    print "Left"
elif A+B < C+D:
    print "Right"
else:
    print "Balanced"

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
def inputs(s):
    li = s.split(" ")
    return(li)

def libra(li):
    left = int(li[0]) + int(li[1])
    right = int(li[2]) + int(li[3])
    if(left > right):
        print("Left")
    elif(left < right):
        print("Right")
    else:
        print("Balanced")

def main():
    s = input()
    li = inputs(s)
    libra(li)

if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

def main():
    ans = A + B - C - D
    if ans > 0:
        print('Left')
    elif ans < 0:
        print('Right')
    else:
        print('Balanced')

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
a, b, c, d = map(int, input().split())
left = a + b
right = c + d

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

Submission status: Accepted

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

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


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import sys
from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt, ceil, floor
from collections import deque
from bisect import bisect, bisect_left, bisect_right
from string import ascii_lowercase
from functools import lru_cache, reduce
from operator import xor
from heapq import heappush, heappop
INF = float("inf")
sys.setrecursionlimit(10**7)

# 4近傍（右, 下, 左, 上）
dy4, dx4 = [0, -1, 0, 1], [1, 0, -1, 0]


def inside(y: int, x: int, H: int, W: int) -> bool: return 0 <= y < H and 0 <= x < W
def ceil(a, b): return (a + b - 1) // b


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


if __name__ == '__main__':
    main()

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())
L = A + B
R = C + D
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")
if L < R:
    print("Right")
if L == R:
    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:
p=[int(x) for x	in input().split()]
a=p[0]
b=p[1]
c=p[2]
d=p[3]
e=a+b
f=c+d
if e<f:
    print('Right')
elif e>f:
    print('Left')
else:
    print('Balanced')

Submission status: Accepted

Solution code:
a,b,c,d=[int(i) for i in 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())
suma=a+b
sumb=c+d
if suma>sumb:
    print('Left')
elif suma==sumb:
    print('Balanced')
else:
    print('Right')

Submission status: Accepted

Solution code:
exec"print['Balanced','Left','Right'][cmp(%s+%s,%s+%s)]"%tuple(raw_input().split())

Submission status: Accepted

Solution code:
n=list(map(int,input().split()))
l=n[0]+n[1]
r=n[2]+n[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())
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:
# -*- 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:
weights = list(map(int, input().split()))

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

Submission status: Accepted

Solution code:
#abc083

a,b,c,d=map(int,raw_input().split())
wl=a+b
wr=c+d
if wl>wr:
 print 'Left'
elif wl<wr:
 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:
#!/usr/bin/env python3
A, B, C, D = list(map(int, input().split()))
ans = (A + B) - (C + D)
print('Left' if (ans > 0) else 'Right' if (ans < 0) else 'Balanced')

Submission status: Accepted

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

res = ""
if A + B == C + D:
	res = "Balanced"
elif A + B < C + D:
	res = "Right"
else:
	res = "Left"

print(res)

Submission status: Accepted

Solution code:
a,b,c,d = map(int, raw_input().strip().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('Balanced')
if a + b > c + d: print('Left')
if a + b < c + d: 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:
import sys
import math

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())
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:
s = input()

slist = s.split(" ")

left = int(slist[0]) + int(slist[1])

right = int(slist[2]) + int(slist[3])

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

Submission status: Accepted

Solution code:
nums = list(map(int, input().split()))
a = nums[0]
b = nums[1]
c = nums[2]
d = nums[3]

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:
# -*- coding: utf-8 -*-
import sys
from math import *
if __name__ =="__main__":
    str_in = input()
    num = [int(n) for n in str_in.split()]
    A,B,C,D=num
    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=map(int, raw_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:
# スペース区切りの整数の入力
a, b, c, d= map(int, input().split())

left = a + b
right = c + d

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
A,B,C,D = map(int, input().split())
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 = (int(x) for x in input().split())
print('Balanced' if a+b==c+d else 'Left' if a+b > c+d else 'Right')

Submission status: Accepted

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

Submission status: Accepted

Solution code:
N = list(map(int, input().split()))

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

Submission status: Accepted

Solution code:
#!/user/bin/python
# 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:
l = tuple(map(int, input().split()))

R = l[2] + l[3]
L = l[0] + l[1]

if(L < R):
    print("Right")
elif(L > R):
    print("Left")
elif(L == R):
    print("Balanced")

Submission status: Accepted

Solution code:
# coding: utf-8

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

Submission status: Accepted

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

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

else:
	print("Balanced")

Submission status: Accepted

Solution code:
A, B, C, D = map(int, raw_input().split(' '))

if A + B > C + D:
    print 'Left'
elif A + B < C + D:
    print 'Right'
else:
    print 'Balanced'

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a,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:
IN=input()
s=IN.split(" ")
L=int(s[0])+int(s[1])
R=int(s[2])+int(s[3])
if L>R:
    print("Left")
if L==R:
    print("Balanced")
if R>L:
    print("Right")

Submission status: Accepted

Solution code:

input_line = input().rstrip().split(' ')

result = 'Balanced'
left_weight = int(input_line[0]) + int(input_line[1])
right_weight = int(input_line[2]) + int(input_line[3])

if (left_weight > right_weight):
	result = 'Left'
elif (left_weight < right_weight):
	result = 'Right'

print(result)

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=[int(x) for x 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] = [int(n) for n in input().split()]
if a + b > c + d:
    print("Left")
elif a + b == c + d:
    print("Balanced")
else:
    print("Right")

Submission status: Accepted

Solution code:
a,b,c,d=[int(x) for x 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:
# -*- coding:utf-8 -*-


def main(lst):
    left = lst[0] + lst[1]
    right = lst[2] + lst[3]
    if left > right:
        print("Left")
    elif right > left:
        print("Right")
    else:
        print("Balanced")


if __name__ == "__main__":
    lst = [int(val) for val in input().split()]
    main(lst)

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:
# -*- coding: utf-8 -*-
from pprint import pprint as pp

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

Submission status: Accepted

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

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

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

Submission status: Accepted

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

lsum = a+b
rsum = c+d


if lsum<rsum:
    print('Right')
elif lsum==rsum:
    print('Balanced')
else:
    print('Left')

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from itertools import combinations, product,cycle
from fractions import gcd
from collections import defaultdict

left = 0
right = 0
for i,value in enumerate(input().split(" ")):
    if i == 0 or i == 1:
        left += int(value)
    else:
        right += int(value)
if left > right:
    print("Left")
elif  left < right:
    print("Right")
else:
    print("Balanced")

Submission status: Accepted

Solution code:
temp=input()
temp=temp.split(" ")
p=[]
for i in temp:
    p.append(int(i))
if p[0]+p[1]==p[2]+p[3]:
    print("Balanced")
if p[0]+p[1]<p[2]+p[3]:
    print("Right")
if p[0]+p[1]>p[2]+p[3]:
    print("Left")

Submission status: Accepted

Solution code:
#!/usr/bin/python

import sys

def main(argv):
    line = sys.stdin.readline()
    while line:
        values = map(lambda x: int(x), line.rstrip("\n").split())
        left = values[0] + values[1]
        right = values[2] + values[3]
        if left == right:
            print "Balanced"
        elif left > right:
            print "Left"
        else:
            print "Right"

        line = sys.stdin.readline()

if __name__ == "__main__":
    main(sys.argv)

Submission status: Accepted

Solution code:
w=list(map(int, input().split()))

s1=w[0]+w[1]
s2=w[2]+w[3]

if s1>s2:
    print("Left")
elif s1<s2:
    print("Right")
else:
    print("Balanced")

Submission status: Accepted

Solution code:
A=input().split(' ')
l=int(A[0])+int(A[1])
r=int(A[2])+int(A[3])
if l==r:
  	print('Balanced\n')
elif l>r:
  	print('Left\n')
else:
  	print('Right\n')

Submission status: Accepted

Solution code:
[A, B, C, D] = map(int, raw_input().split())

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

Submission status: Accepted

Solution code:
a = list(map(int,input().split()))

left = 0
right = 0
for i, _a in enumerate(a):
    if i < 2:
        left = left + _a
    else:
        right = right + _a

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

Submission status: Accepted

Solution code:
weight_list = list(map(int, input().split()))
left = weight_list[0] + weight_list[1]
right = weight_list[2] + weight_list[3]
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())
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('Balanced')
elif (a+b) > (c+d):
   print('Left')
else:
   print('Right')

Submission status: Accepted

Solution code:
# coding:utf-8

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

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

Submission status: Accepted

Solution code:
wei = list(map(int, input().split()))
l = wei[0] + wei[1]
r = wei[2] + wei[3]

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

Submission status: Accepted

Solution code:
# coding: utf-8
# Your code here!
a,b,c,d=map(int,input().split())
a=a+b
c=c+d

if a>c:
    print('Left')
elif a==c:
    print('Balanced')
else:
    print('Right')

Submission status: Accepted

Solution code:
A,B,C,D=map(int,raw_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())

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 = list(map(int, input().split()))

left = A + B
right = C + D

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