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

# # get single (or) multiple str
# X = input()

# # get single int
# N = int(input())
# # get multiple int (e.g., 2)
# X, Y = map(int, input().split())
# # get multiple int (e.g., 2) for N lines
# XY = [list(map(int, input().split())) for _ in range(N)]

# from IPython import embed; embed(); exit();

# 全部入り
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
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
import numpy as np
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("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('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())
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(T) for T in input().split())
L = A+B
R = C+D
print(['Balanced','Left','Right'][(L!=R)+(L<R)])

Submission status: Accepted

Solution code:
import sys
def MI(): return map(int,sys.stdin.readline().rstrip().split())

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

if a + b < c + d:
    print("Right")
elif a + b > c + d:
    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 r > l:
    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:
def resolve():
    l1, l2, r1, r2 = map(int, input().split())
    lw = l1 + l2
    rw = r1 + r2
    
    ans = ""
    if lw < rw:
        ans = "Right"
    elif lw > rw:
        ans = "Left"
    else:
        ans = "Balanced"
    print(ans)
resolve()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
in_list = input().split(' ')
A = in_list[0]
B = in_list[1]
C = in_list[2]
D = in_list[3]

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

Submission status: Accepted

Solution code:
A,B,C,D=map(int,input().split()) #1行で1スペースあけて入力


l=A+B
r=C+D

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)

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

Submission status: Accepted

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

if __name__ == "__main__":
  resolve()

Submission status: Accepted

Solution code:
from sys import stdin
nii=lambda:map(int,stdin.readline().split())
lnii=lambda:list(map(int,stdin.readline().splt()))

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

Submission status: Accepted

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

Submission status: Accepted

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

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

L = A + B
R = C + D

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
#N = int(input())
#S = str(input())
A, B, C, D = map(int, input().split())
#C = list(map(int, input().split()))


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

Submission status: Accepted

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


if __name__ == "__main__":
    solve()

Submission status: Accepted

Solution code:
A, B, C, D = map(int, input().split())
print("Right" if (A+B) < (C+D) else "Balanced" if (A+B) == (C+D) else "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('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:
L = list(map(int, input().split()))
if sum(L[:2]) == sum(L[2:]):
    print('Balanced' , flush=True)
elif sum(L[:2]) > sum(L[2:]):
    print('Left' , flush=True)
else:
    print('Right' , flush=True)

Submission status: Accepted

Solution code:
import sys
def input(): return sys.stdin.readline().strip()


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



if __name__ == "__main__":
    main()

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

Submission status: Accepted

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

Submission status: Accepted

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

L = A + B
R = C + D

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#n=int(input())
a,b,c,d=map(int,input().split())
#l=list(map(int,input().split()))
#l=[list(map(int,input().split())) for i in range(n)]

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

Submission status: Accepted

Solution code:
import sys, os, math, bisect, itertools, collections, heapq, queue
# from scipy.sparse.csgraph import csgraph_from_dense, floyd_warshall
from decimal import Decimal
from collections import defaultdict, deque

sys.setrecursionlimit(10000000)

ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]

iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]

lcm = lambda x, y: (x * y) // math.gcd(x, y)

MOD = 10 ** 9 + 7
MAX = float('inf')


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

    a, b, c, d = il()
    print('Right' if a + b < c + d else 'Balanced' if a + b == c + d else 'Left')


if __name__ == '__main__':
    main()

Submission status: Accepted

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

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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

if x == y:
    print('Balanced')
elif x > y:
    print('Left')
else:
    print('Right')

Submission status: Accepted

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

y = a + b 
z = c + d 

if y==z:
    print("Balanced")
elif y>z:
    print("Left")
else:
    print("Right")

Submission status: Accepted

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

L=A+B
R=C+D

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

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline

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

Submission status: Accepted

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

# check
L = sum(ABCD[:2])
R = sum(ABCD[2:])
if L == R:
    print("Balanced")
elif L > R:
    print("Left")
else:
    print("Right")

Submission status: Accepted

Solution code:
import sys
import math
import itertools
import collections
import heapq
import re
import numpy as np

rr = lambda: sys.stdin.readline().rstrip()
rs = lambda: sys.stdin.readline().split()
ri = lambda: int(sys.stdin.readline())
rm = lambda: map(int, sys.stdin.readline().split())
rl = lambda: list(map(int, sys.stdin.readline().split()))
inf = float('inf')
mod = 10**9 + 7


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

Submission status: Accepted

Solution code:
###==================================================
### import
#import bisect
#from collections import Counter, deque, defaultdict
#from copy import deepcopy
#from functools import reduce, lru_cache
#from heapq import heappush, heappop
#import itertools
#import math
#import string
import sys
### stdin
def input(): return sys.stdin.readline().rstrip()
def iIn(): return int(input())
def iInM(): return map(int, input().split())
def iInM1(): return map(int1, input().split())
def iInLH(): return list(map(int, input().split()))
def iInLH1(): return list(map(int1, input().split()))
def iInLV(n): return [iIn() for _ in range(n)]
def iInLV1(n): return [iIn()-1 for _ in range(n)]
def iInLD(n): return [iInLH() for _ in range(n)]
def iInLD1(n): return [iInLH1() for _ in range(n)]
def sInLH(): return list(input().split())
def sInLV(n): return [input().rstrip('\n') for _ in range(n)]
def sInLD(n): return [sInLH() for _ in range(n)]
### stdout
def OutH(lst, deli=' '): print(deli.join(map(str, lst)))
def OutV(lst): print('\n'.join(map(str, lst)))
### setting
sys.setrecursionlimit(10 ** 6)
### utils
int1 = lambda x: int(x) - 1
### constants
INF = int(1e9)
MOD = 1000000007
dx = (-1, 0, 1, 0)
dy = (0, -1, 0, 1)
###---------------------------------------------------

A, B, C, D = iInM()

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

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

Submission status: Accepted

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

if not (1 <= A <= 10 and 1 <= B <= 10 and 1 <= C <= 10 and 1 <= D <= 10):
    sys.exit()

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

else:
    print("Balanced")

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

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

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

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())
print(['RLiegfhtt'[a+b>c+d::2],'Balanced'][a+b==c+d])

Submission status: Accepted

Solution code:
l=list(map(int,input().split()));print("Left" if sum(l[:2])>sum(l[2:]) else "Balanced" if sum(l[:2])==sum(l[2:]) else "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('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')
elif A+B<C+D:
  print('Right')
else:
  print('Left')

Submission status: Accepted

Solution code:
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
def s(): return input()
def i(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
sys.setrecursionlimit(10 ** 9)
INF = 10**9
mod = 10**9+7

A,B,C,D = I()
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())

L = int(A + B)
R = int(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 -*-

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(10000000)
MOD = 10 ** 9 + 7
INF = 10 ** 15

def main():
    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')
if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

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

ab = a + b
cd = c + d

if(ab > cd):
    print('Left')
elif(ab < cd):
    print('Right')
else:
    print('Balanced')

Submission status: Accepted

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

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def actual(a, b, c, d):
    L, R = a + b, c + d

    if L > R:
        return 'Left'
    if L < R:
        return 'Right'

    return 'Balanced'

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

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

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());print('RLiegfhtt'[a+b>c+d::2]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())
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())

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

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

Submission status: Accepted

Solution code:
import bisect,collections,copy,heapq,itertools,math,string
import sys
def S(): return sys.stdin.readline().rstrip()
def M(): return map(int,sys.stdin.readline().rstrip().split())
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LS(): return list(sys.stdin.readline().rstrip().split())
a, b, c, d = M()
if a+b > c+d:
    print('Left')
elif a+b == c+d:
    print('Balanced')
else:
    print('Right')