Problem:


Score : 200 points

Problem Statement

You are given two positive integers A and B. Compare the magnitudes of these numbers.

Constraints

1 ≤ A, B ≤ 10^{100}

Neither A nor B begins with a 0.

Input

Input is given from Standard Input in the following format:

A
B

Output

Print GREATER if A>B, LESS if A<B and EQUAL if A=B.

Sample Input 1

36
24

Sample Output 1

GREATER

Since 36>24, print GREATER.

Sample Input 2

850
3777

Sample Output 2

LESS

Sample Input 3

9720246
22516266

Sample Output 3

LESS

Sample Input 4

123456789012345678901234567890
234567890123456789012345678901

Sample Output 4

LESS



Sample input:
36
24


Sample output:
GREATER

Submission status: Accepted

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

import sys
# import time
# import math
# import numpy as np
# import scipy.sparse.csgraph as cs            # csgraph_from_dense(ndarray, null_value=inf), bellman_ford(G, return_predecessors=True), dijkstra, floyd_warshall
# import random                                # random, uniform, randint, randrange, shuffle, sample
# import string                                # ascii_lowercase, ascii_uppercase, ascii_letters, digits, hexdigits
# import re                                    # re.compile(pattern) => ptn obj; p.search(s), p.match(s), p.finditer(s) => match obj; p.sub(after, s)
# from bisect import bisect_left, bisect_right # bisect_left(a, x, lo=0, hi=len(a)) returns i such that all(val<x for val in a[lo:i]) and all(val>-=x for val in a[i:hi]).
# from collections import deque                # deque class. deque(L): dq.append(x), dq.appendleft(x), dq.pop(), dq.popleft(), dq.rotate()
# from collections import defaultdict          # subclass of dict. defaultdict(facroty)
# from collections import Counter              # subclass of dict. Counter(iter): c.elements(), c.most_common(n), c.subtract(iter)
# from datetime import date, datetime          # date.today(), date(year,month,day) => date obj; datetime.now(), datetime(year,month,day,hour,second,microsecond) => datetime obj; subtraction => timedelta obj
# from datetime.datetime import strptime       # strptime('2019/01/01 10:05:20', '%Y/%m/%d/ %H:%M:%S') returns datetime obj
# from datetime import timedelta               # td.days, td.seconds, td.microseconds, td.total_seconds(). abs function is also available.
# from copy import copy, deepcopy              # use deepcopy to copy multi-dimentional matrix without reference
# from functools import reduce                 # reduce(f, iter[, init])
# from functools import lru_cache              # @lrucache ...arguments of functions should be able to be keys of dict (e.g. list is not allowed)
# from heapq import heapify, heappush, heappop # built-in list. heapify(L) changes list in-place to min-heap in O(n), heappush(heapL, x) and heappop(heapL) in O(lgn).
# from heapq import nlargest, nsmallest        # nlargest(n, iter[, key]) returns k-largest-list in O(n+klgn).
# from itertools import count, cycle, repeat   # count(start[,step]), cycle(iter), repeat(elm[,n])
# from itertools import groupby                # [(k, list(g)) for k, g in groupby('000112')] returns [('0',['0','0','0']), ('1',['1','1']), ('2',['2'])]
# from itertools import starmap                # starmap(pow, [[2,5], [3,2]]) returns [32, 9]
# from itertools import product, permutations  # product(iter, repeat=n), permutations(iter[,r])
# from itertools import combinations, combinations_with_replacement
# from itertools import accumulate             # accumulate(iter[, f])
# from operator import itemgetter              # itemgetter(1), itemgetter('key')
# from fractions import gcd                    # for Python 3.4 (previous contest @AtCoder)



def main():
    mod = 1000000007                # 10^9+7
    inf = float('inf')              # sys.float_info.max = 1.79...e+308
    # inf = 2 ** 64 - 1             # (for fast JIT compile in PyPy) 1.84...e+19
    sys.setrecursionlimit(10**6)    # 1000 -> 1000000
    def input(): return sys.stdin.readline().rstrip()
    def ii():    return int(input())
    def mi():    return map(int, input().split())
    def mi_0():  return map(lambda x: int(x)-1, input().split())
    def lmi():   return list(map(int, input().split()))
    def lmi_0(): return list(map(lambda x: int(x)-1, input().split()))
    def li():    return list(input())
    
    
    a = ii()
    b = ii()
    if a > b:
        print('GREATER') 
    elif a == b:
        print('EQUAL')
    else:
        print('LESS')


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
a = input()
b = input()
if a == b:
	print("EQUAL")
elif len(a) < len(b):
	print("LESS")
elif len(a) > len(b):
	print("GREATER")
elif a < b:
	print("LESS")
else:
	print("GREATER")

Submission status: Accepted

Solution code:
A=int(input())
B=int(input())

if A>B:
	print("GREATER")
elif A<B:
	print("LESS")
else:
	print("EQUAL")

Submission status: Accepted

Solution code:
a=int(input())
b=int(input())
print('GREATER' if a>b else 'LESS' if a<b else 'EQUAL')

Submission status: Accepted

Solution code:
A = int(input())
B = int(input())
if A > B:
  print('GREATER')
elif A == B:
  print('EQUAL')
else:
  print('LESS')

Submission status: Accepted

Solution code:
a = input()
b = input()

if(len(a) > len(b)):
  print("GREATER")
elif(len(a) < len(b)):
  print("LESS")
elif(len(a) == len(b)):
  if(int(a) == int(b)):
    print("EQUAL")
  elif(int(a) > int(b)):
    print("GREATER")
  else:
    print("LESS")

Submission status: Accepted

Solution code:
a = int(input())
b = int(input())

if a > b:
  print('GREATER')
elif a < b:
  print('LESS')
else:
  print('EQUAL')

Submission status: Accepted

Solution code:
A = int(input())
B = int(input())
print("GREATER" if A > B else "LESS" if A < B else "EQUAL")

Submission status: Accepted

Solution code:
a = int(input())
b = int(input())

if a>b :
    print("GREATER")
elif a<b:
    print("LESS")
elif a == b:
    print("EQUAL")

Submission status: Accepted

Solution code:
import sys
import heapq, math
from itertools import zip_longest, permutations, combinations, combinations_with_replacement
from itertools import accumulate, dropwhile, takewhile, groupby
from functools import lru_cache
from copy import deepcopy

A = input()
B = input()

if len(A) != len(B):
    print("GREATER" if len(A) > len(B) else "LESS")
else:
    def lt(A, B):
        l = len(A)
        for i in range(l):
            if A[i] > B[i]:
                return "GREATER"
            elif A[i] < B[i]:
                return "LESS"
        return "EQUAL"

    print(lt(A, B))

Submission status: Accepted

Solution code:
A = int(input())
B = int(input())

if A > B:
    print("GREATER")
elif A == B:
    print("EQUAL")
else:
    print("LESS")

Submission status: Accepted

Solution code:
a=int(input())
b=int(input())

if a>b:
    print("GREATER")
elif a<b:
    print("LESS")
else:
    print("EQUAL")

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
A, B = map(int, open(0))
print('GREATER' if A > B else 'LESS' if A < B else 'EQUAL')

Submission status: Accepted

Solution code:
A = int(input())
B = int(input())

print("GREATER" if A>B else ("LESS" if A<B else "EQUAL"))

Submission status: Accepted

Solution code:
a = input()
b = input()
if len(a) > len(b):
    print('GREATER')
    exit()
if len(a) < len(b):
    print('LESS')
    exit()
for i in range(len(a)):
    if a[i] > b[i]:
        print('GREATER')
        exit()
    if a[i] < b[i]:
        print('LESS')
        exit()
print('EQUAL')

Submission status: Accepted

Solution code:
# coding: utf-8
A = int(input())
B = int(input())
if A == B:
    print('EQUAL')
elif A > B:
    print('GREATER')
else:
    print('LESS')

Submission status: Accepted

Solution code:
a = int(input())
b = int(input())
if  a > b:
    print('GREATER')
elif a < b:
    print('LESS')
else:
    print('EQUAL')

Submission status: Accepted

Solution code:
A=int(input())
B=int(input())
if A>B:
  print('GREATER')
elif A==B:
  print('EQUAL')
else:
  print('LESS')

Submission status: Accepted

Solution code:
A = int(input())
B = int(input())

if A > B:
    print("GREATER")
elif A < B:
    print("LESS")
else:
    print("EQUAL")

Submission status: Accepted

Solution code:
A = int(input())
B = int(input())

if A>B:
  print("GREATER")
if A<B:
  print("LESS")
if A==B:
  print("EQUAL")

Submission status: Accepted

Solution code:
A = int(input())
B= int(input())

if A>B:
    print("GREATER")
elif A<B:
    print("LESS")
elif A==B:
    print("EQUAL")

Submission status: Accepted

Solution code:
A = int(input())
B = int(input())

if A == B:
    print("EQUAL")
elif A < B:
    print("LESS")
else:
    print("GREATER")

Submission status: Accepted

Solution code:
A = input()
B = input()
if len(A) > len(B):
    print('GREATER')
elif len(A) < len(B):
    print('LESS')
else:
    for i in range(len(A)):
        if int(A[i]) > int(B[i]):
            print('GREATER')
            break
        elif int(A[i]) < int(B[i]):
            print('LESS')
            break
    else:
        print('EQUAL')

Submission status: Accepted

Solution code:
A = int(input())
B = int(input())
if A > B:
    print("GREATER")
elif A == B:
    print("EQUAL")
else:
    print("LESS")

Submission status: Accepted

Solution code:
A=int(input())
B=int(input())
if A>B:
    print('GREATER')
elif A<B:
    print('LESS')
else:
    print('EQUAL')

Submission status: Accepted

Solution code:
a = int(input())
b = int(input())

if a > b :
    print("GREATER")
elif a== b:
    print("EQUAL")
else:
    print("LESS")

Submission status: Accepted

Solution code:
from sys import stdin, stdout 

a = int(stdin.readline()) 
b = int(stdin.readline())

if a > b:
    stdout.write(str('GREATER'))
elif a < b:
    stdout.write(str('LESS'))
else:
    stdout.write(str('EQUAL'))

Submission status: Accepted

Solution code:
a = int(input())
b = int(input())

ans = 'EQUAL'
if a > b:
    ans = 'GREATER'
elif a< b:
    ans = 'LESS'
print(ans)

Submission status: Accepted

Solution code:
a = int(input())
b = int(input())

if a == b:
    print("EQUAL")
elif a > b:
    print("GREATER")
else:
    print("LESS")

Submission status: Accepted

Solution code:
import sys
import math
import bisect

def main():
    a = int(input())
    b = int(input())
    if a < b:
        print('LESS')
    elif a > b:
        print('GREATER')
    else:
        print('EQUAL')

if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
a = int(input())
b = int(input())
if a > b:
	print("GREATER")
elif a < b:
	print("LESS")
elif a == b:
	print("EQUAL")

Submission status: Accepted

Solution code:
import math
import copy

neko = 0
nuko = 0
inu = 0

a = int(input())
b = int(input())
if a> b:
    print('GREATER')
elif a < b:
    print('LESS')
else:
    print('EQUAL')

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
"""
Created on Thu May 14 16:34:41 2020

@author: shinba
"""

a = input()
b = input()

if len(a) > len(b):
    print("GREATER")
elif len(b) > len(a):
    print("LESS")
else:
    for i in range(len(a)):
        if int(a[i]) > int(b[i]):
            print("GREATER")
            break
        elif int(b[i]) > int(a[i]):
            print("LESS")
            break
    else:
        print("EQUAL")

Submission status: Accepted

Solution code:
import sys

A = input()
B = input()

if len(A)>len(B):
    print("GREATER")
elif len(A)<len(B):
    print("LESS")
else:
    for i in range(len(A)):
        if A[i] > B[i]:
            print("GREATER")
            sys.exit()
        elif A[i] < B[i]:
            print("LESS")
            sys.exit()
        else:
            continue
    else:
        print("EQUAL")

Submission status: Accepted

Solution code:
import sys

A = input()
B = input()

if len(A)>len(B):
    print("GREATER")
elif len(A)<len(B):
    print("LESS")
else:
    for i in range(len(A)):
        if int(A[i])>int(B[i]):
            print("GREATER")
            sys.exit()
        elif int(A[i])<int(B[i]):
            print("LESS")
            sys.exit()
        else:
            continue
    else:
        print("EQUAL")

Submission status: Accepted

Solution code:
def main():
    a = int(input())
    b = int(input())
    if a > b:
        ans = "GREATER"
    elif a < b:
        ans = "LESS"
    else:
        ans = "EQUAL"
    print(ans)


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
a = int(input())
b = int(input())
if (a > b):
  print("GREATER")
elif (a < b):
  print("LESS")
else:
  print("EQUAL")

Submission status: Accepted

Solution code:
a = int(input())
b = int(input())
if a > b:
  print('GREATER')
elif a == b:
  print('EQUAL')
else:
  print('LESS')

Submission status: Accepted

Solution code:
A=int(input())
B=int(input())
if A>B:
    print("GREATER")
elif A<B:
    print("LESS")
else:
    print("EQUAL")

Submission status: Accepted

Solution code:
#print#!/usr/bin/env python3
#%% for atcoder uniittest use
import sys
input= lambda: sys.stdin.readline().rstrip()
sys.setrecursionlimit(10**9)
def pin(type=int):return map(type,input().split())
def tupin(t=int):return tuple(pin(t))
def lispin(t=int):return list(pin(t))
#%%code
from collections import Counter
def resolve():
    A=int(input())
    B=int(input())
    if A==B:print("EQUAL")
    else:print(["LESS","GREATER"][A>B])

#%%submit!
resolve()

Submission status: Accepted

Solution code:
A = int(input())
B = int(input())
if A == B:
    print('EQUAL')
elif A > B:
    print('GREATER')
else:
    print('LESS')

Submission status: Accepted

Solution code:
A = int(input())
B = int(input())
# C = int(input())
# s= input()
print("GREATER" if A > B else "LESS" if A < B else "EQUAL")

Submission status: Accepted

Solution code:
a = int(input())
b = int(input())

if a>b:
  print("GREATER")
elif a==b:
  print("EQUAL")
else:
  print("LESS")

Submission status: Accepted

Solution code:
import math
a = math.log(int(input()))
b = math.log(int(input()))
if a > b:
  print("GREATER")
elif a < b:
  print("LESS")
else:
  print("EQUAL")

Submission status: Accepted

Solution code:
A = input()
B = input()

if len(A) > len(B):
    print("GREATER")
elif len(A) < len(B):
    print("LESS")
else:
    i = 0
    while True:
        if A[i] > B[i]:
            print("GREATER")
            break
        elif A[i] < B[i]:
            print("LESS")
            break
        else:
            if i == len(A)-1:
                print("EQUAL")
                break
            else:
                i += 1

Submission status: Accepted

Solution code:
A=int(input())
B=int(input())

if A>B:
    print('GREATER')
elif A<B:
    print('LESS')
else:
    print('EQUAL')

Submission status: Accepted

Solution code:
def main():
    A = int(input())
    B = int(input())

    if A > B:
        print('GREATER')
    elif A < B:
        print('LESS')
    else:
        print('EQUAL')


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
A=int(input())
B=int(input())

if A>B:
  print("GREATER")
elif A<B:
  print("LESS")
else:
  print("EQUAL")

Submission status: Accepted

Solution code:
a = int(input())
b = int(input())
if a>b:
  print("GREATER")
elif b>a:
  print("LESS")
else:
  print("EQUAL")

Submission status: Accepted

Solution code:
a=int(input())
b=int(input())

if a>b:
  print("GREATER")
elif a==b:
  print("EQUAL")
else:
  print("LESS")

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, log2
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
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 = INT()
B = INT()

if A > B:
	print("GREATER")
elif A < B:
	print("LESS")
else:
	print("EQUAL")

Submission status: Accepted

Solution code:
A, B = int(input()), int(input())
if A > B:
    print('GREATER')
elif A < B:
    print('LESS')
else:
    print('EQUAL')

Submission status: Accepted

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

def resolve():
    a=int(input())
    b=int(input())
    if a>b:
        print('GREATER')
    elif a<b:
        print('LESS')
    else:
        print('EQUAL')
resolve()

Submission status: Accepted

Solution code:
A = int(input())
B = int(input())

print("GREATER" if A>B else "LESS" if A<B else "EQUAL")

Submission status: Accepted

Solution code:
a, b = map(int, open(0).read().split())
if a > b:
    print('GREATER')
elif a < b:
    print('LESS')
else:
    print('EQUAL')

Submission status: Accepted

Solution code:
a = int(input())
b = int(input())

if a>b :
    print("GREATER")
elif a<b:
    print("LESS")
else:
    print("EQUAL")

Submission status: Accepted

Solution code:
a = int(input())
b = int(input())
if a>b:print('GREATER')
elif b>a:print('LESS')
else:print('EQUAL')

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
from operator import itemgetter
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)]
def printns(x): print('\n'.join(x))
def printni(x): print('\n'.join(list(map(str,x))))
inf = 10**17
mod = 10**9 + 7
#s=input().rstrip()

a=I()
b=I()
if a>b:
    print("GREATER")
elif a==b:
    print("EQUAL")
else:
    print("LESS")

Submission status: Accepted

Solution code:
a = int(input())
b = int(input())
if a>b:
  print("GREATER")
  
elif a == b:
  print("EQUAL")
  
else:
  print("LESS")

Submission status: Accepted

Solution code:
A = int(input())
B = int(input())
if A > B:
  ans = 'GREATER'
elif A == B:
  ans = 'EQUAL'
elif A < B:
  ans = 'LESS'
print(ans)

Submission status: Accepted

Solution code:
a = int(input())
b = int(input())
print('GREATER' if a > b else 'LESS' if a < b else 'EQUAL')

Submission status: Accepted

Solution code:
a = input()
b = input()
la = len(a)
lb = len(b)
if la > lb:
  print('GREATER')
elif la==lb:
  if a > b:
    print('GREATER')
  elif a==b:
    print('EQUAL')
  else:
    print('LESS')  
else:
  print('LESS')

Submission status: Accepted

Solution code:
a = int(input())
b = int(input())
if a<b:
    print('LESS')
elif a>b:
    print('GREATER')
else:
    print('EQUAL')

Submission status: Accepted

Solution code:
a = input()
b = input()
a = a.zfill(101)
b = b.zfill(101)
if a<b:
    print('LESS')
elif a>b:
    print('GREATER')
else:
    print('EQUAL')

Submission status: Accepted

Solution code:
a = input()
b = input()
if len(a)<len(b):
    print('LESS')
elif len(a)>len(b):
    print('GREATER')
else:
    for aa, bb in zip(a, b):
        if aa<bb:
            print('LESS')
            break
        elif aa>bb:
            print('GREATER')
            break
    else:
        print('EQUAL')

Submission status: Accepted

Solution code:
A = int(input())
B = int(input())

print('GREATER' if A > B else 'EQUAL' if A==B else 'LESS')

Submission status: Accepted

Solution code:
a, b = int(input()), int(input())
print("EQUAL" if a == b else ("GREATER" if a > b else "LESS"))

Submission status: Accepted

Solution code:
a=input()
b=input()
ans="EQUAL"
if len(a)!=len(b):
  if(len(a)>len(b)):
    ans="GREATER"
  else:
    ans="LESS"
else:
  for i in range(len(a)):
    if int(a[i])>int(b[i]):
      ans="GREATER"
      break
    if int(a[i])<int(b[i]):
      ans="LESS"
      break
print(ans)

Submission status: Accepted

Solution code:
A = int(input())
B = int(input())
if A < B:
    print('LESS')
if A == B:
    print('EQUAL')
if A > B:
    print('GREATER')

Submission status: Accepted

Solution code:
a,b=int(input()), int(input())
print("EQUAL" if a == b else ("LESS" if a < b else "GREATER"))

Submission status: Accepted

Solution code:
a = int(input())
b = int(input())
if a > b :
    print("GREATER")
elif a < b :
    print("LESS")
elif a == b:
    print("EQUAL")

Submission status: Accepted

Solution code:
a = int(input())
b = int(input())

if a>b:
    print("GREATER")
elif a == b:
    print("EQUAL")
else:
    print("LESS")

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 ##
def DD2(d1,d2,init=0): return [[init]*d2 for _ in range(d1)]
def DD3(d1,d2,d3,init=0): return [DD2(d2,d3,init) for _ in range(d1)]
## math ##
def to_bin(x: int) -> str: return format(x, 'b') # rev => int(res, 2)
def to_oct(x: int) -> str: return format(x, 'o') # rev => int(res, 8)
def to_hex(x: int) -> str: return format(x, 'x') # rev => int(res, 16)
MOD=10**9+7
def divc(x,y) -> int: return -(-x//y)
def divf(x,y) -> int: 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 enumerate_divs(n):
    """Return a tuple list of divisor of n"""
    return [(i,n//i) for i in range(1,int(n**0.5)+1) if n%i==0]
def get_primes(MAX_NUM=10**3):
    """Return a list of prime numbers n or less"""
    is_prime = [True]*(MAX_NUM+1)
    is_prime[0] = is_prime[1] = False
    for i in range(2, int(MAX_NUM**0.5)+1):
        if not is_prime[i]: continue
        for j in range(i*2, MAX_NUM+1, i):
            is_prime[j] = False
    return [i for i in range(MAX_NUM+1) if is_prime[i]]
## 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 = II()
    b = II()
    if a > b: print('GREATER')
    elif a < b: print('LESS')
    else: print('EQUAL')

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
a=int(input())
b=int(input())
if a>b:
    print('GREATER')
elif a==b:
    print('EQUAL')
else:
    print('LESS')

Submission status: Accepted

Solution code:
A=int(input())
B=int(input())
if A>B:
    ans="GREATER"
elif A==B:
    ans="EQUAL"
else:
    ans="LESS"
print(ans)

Submission status: Accepted

Solution code:
a = int(input())
b = int(input())

if (a > b):
    print('GREATER')
elif (a == b):
    print('EQUAL')
else:
    print('LESS')

Submission status: Accepted

Solution code:
A = int(input())
B = int(input())
if(A > B):
  print("GREATER")
elif(A == B):
  print("EQUAL")
else:
  print("LESS")

Submission status: Accepted

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

a=input()
b=input()
if len(a)>len(b):
    print("GREATER")
elif len(a)<len(b):
    print("LESS")
else:
    for i in range(len(a)):
        if a[i]>b[i]:
            print("GREATER")
            break
        elif a[i]<b[i]:
            print("LESS")
            break
    else:
        print("EQUAL")

Submission status: Accepted

Solution code:
import numpy as np
import sys

input = sys.stdin.readline

A = int(input())
B = int(input())
if A > B:
    print("GREATER")
elif A < B:
    print("LESS")
else:
    print("EQUAL")

Submission status: Accepted

Solution code:
A = int(input())
B = int(input())

if A == B:
  print('EQUAL')
elif A < B:
  print('LESS')
else:
  print('GREATER')

Submission status: Accepted

Solution code:
a=int(input())
b=int(input())
if a<b:
  print("LESS")
elif a>b:
  print("GREATER")
elif a==b:
  print("EQUAL")

Submission status: Accepted

Solution code:
a = int(input())
b = int(input())

if a > b:
    print('GREATER')
elif a < b:
    print('LESS')
elif a == b:
    print('EQUAL')

Submission status: Accepted

Solution code:
def resolve():
    A = int(input())
    B = int(input())
    if A > B:
        print("GREATER")
    elif A == B:
        print("EQUAL")
    else:
        print("LESS")


if '__main__' == __name__:
    resolve()

Submission status: Accepted

Solution code:
a = int(input())
b = int(input())
ans = ''
if a > b:
    ans = 'GREATER'
elif a < b:
    ans = 'LESS'
else:
    ans = 'EQUAL'
print(ans)

Submission status: Accepted

Solution code:
# https://atcoder.jp/contests/abc059/tasks/abc059_b
a = int(input())
b = int(input())

if a > b:
    print('GREATER')
elif a < b:
    print('LESS')
else:
    print('EQUAL')

Submission status: Accepted

Solution code:
a = int(input())
b = int(input())

if a > b:
    print("GREATER")
elif a < b:
    print("LESS")
else:
    print("EQUAL")

Submission status: Accepted

Solution code:
A = int(input())
B = int(input())

if A > B:
  print('GREATER')
elif A == B:
  print('EQUAL')
else:
  print('LESS')

Submission status: Accepted

Solution code:
A=int(input())
B=int(input())

if A>B:
    print("GREATER")
elif A<B:
    print("LESS")
else:
    print("EQUAL")

Submission status: Accepted

Solution code:
A=int(input())
B=int(input())
print('GREATER'if A>B else'LESS'if A<B else'EQUAL')

Submission status: Accepted

Solution code:
import sys

sys.setrecursionlimit(10 ** 7)
f_inf = float('inf')
mod = 10 ** 9 + 7


def resolve():
    a = int(input())
    b = int(input())

    if a > b:
        print("GREATER")
    elif a == b:
        print("EQUAL")
    else:
        print("LESS")


if __name__ == '__main__':
    resolve()

Submission status: Accepted

Solution code:
A = int(input())
B = int(input())

if (A > B):
    print('GREATER')
elif(A == B):
    print('EQUAL')
else:
    print('LESS')

Submission status: Accepted

Solution code:
# 誤差で死ぬ？
a = int(input())
b = int(input())
if a > b:
  print('GREATER')
elif a < b:
  print('LESS')
else:
  print('EQUAL')

Submission status: Accepted

Solution code:
def resolve():
	a = int(input())
	b = int(input())
	if a == b:
		print('EQUAL')
	elif a > b:
		print('GREATER')
	else:
		print('LESS')
resolve()

Submission status: Accepted

Solution code:
a = int(input())
b = int(input())

if a > b:
  print("GREATER")
elif a < b:
  print("LESS")
else:
  print("EQUAL")

Submission status: Accepted

Solution code:
a = int(input())
b = int(input())
if a == b:
    print('EQUAL')
elif a > b:
    print('GREATER')
else:
    print('LESS')

Submission status: Accepted

Solution code:
a = int(input())
b = int(input())
if a>b:
    print('GREATER')
elif a< b:
    print('LESS')
else:
    print('EQUAL')

Submission status: Accepted

Solution code:
a = int(input())
b = int(input())
if b<a:
    print("GREATER")
elif b == a :
    print("EQUAL")
else:
    print('LESS')

Submission status: Accepted

Solution code:
a=int(input())
b=int(input())
s=""
if a==b:
  s="EQUAL"
if a<b:
  s="LESS"
if a>b:
  s="GREATER"
print(s)

Submission status: Accepted

Solution code:
a = int(input())
b = int(input())

if a > b:
  print("GREATER")
if a < b:
  print("LESS")
if a == b:
  print("EQUAL")

Submission status: Accepted

Solution code:
A = input()
B = input()

if len(A) > len(B):
    print("GREATER")
elif len(A) < len(B):
    print("LESS")
else:
    for i in range(len(A)):
        if int(A[i]) > int(B[i]):
            print("GREATER")
            break
        elif int(A[i]) < int(B[i]):
            print("LESS")
            break
    else:
        print("EQUAL")

Submission status: Accepted

Solution code:
import sys
from collections import Counter
readline = sys.stdin.buffer.readline
MOD = 10**9+7

def main():
    A = int(readline())
    B = int(readline())
    if A>B:
        print('GREATER')
    elif A<B:
        print('LESS')
    else:
        print('EQUAL')




if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
a=int(input())
b=int(input())
if a>b:
  print('GREATER')
elif a<b:
  print('LESS')
else:
  print('EQUAL')

Submission status: Accepted

Solution code:
n1=int(input())
n2=int(input())
if n1>n2 :print("GREATER")
if n1==n2:print("EQUAL")
if n1<n2 :print("LESS")

Submission status: Accepted

Solution code:
A,B = map(int,open(0).read().split())
if A> B:
  print("GREATER")
elif A<B:
  print("LESS")
elif A==B:
  print("EQUAL")

Submission status: Accepted

Solution code:
A=int(input())
B=int(input())
 
if A==B:
  print("EQUAL")
elif A>B:
  print("GREATER")
else:
  print("LESS")

Submission status: Accepted

Solution code:
A=int(input())
B=int(input())

if A==B:
  print("EQUAL")
elif A>B:
  print("GREATER")
else:
  print("LESS")

Submission status: Accepted

Solution code:
def main():
    A = int(input())
    B = int(input())
    if A > B:
        print('GREATER')
    elif A < B:
        print('LESS')
    else:
        print('EQUAL')


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
# from math import factorial,sqrt,ceil,gcd
# from itertools import permutations as permus
# from collections import deque,Counter
# import re
# from functools import lru_cache # 簡単メモ化 @lru_cache(maxsize=1000)
# from decimal import Decimal, getcontext
# # getcontext().prec = 1000
# # eps = Decimal(10) ** (-100)

# import numpy as np
# import networkx as nx
# from scipy.sparse.csgraph import shortest_path, dijkstra, floyd_warshall, bellman_ford, johnson
# from scipy.sparse import csr_matrix
# from scipy.special import comb

# slist = "abcdefghijklmnopqrstuvwxyz"
A = int(input())
B = int(input())

num = A-B
if num>0:
    ans = "GREATER"
elif num==0:
    ans = "EQUAL"
else:
    ans = "LESS"

print(ans)
# print(*ans)   # unpackして出力。間にスペースが入る
# for row in board:
#     print(*row,sep="")    #unpackして間にスペース入れずに出力する
# print("{:.10f}".format(ans))
# print("{:0=10d}".format(ans))

Submission status: Accepted

Solution code:
a = int(input()); b = int(input())

if a > b:
    print("GREATER")
elif a < b:
    print("LESS")
else:
    print("EQUAL")

Submission status: Accepted

Solution code:
a = int(input())
b = int(input())
if a > b:
    ans = 'GREATER'
elif a < b:
    ans = 'LESS'
else:
    ans = 'EQUAL'
print(ans)

Submission status: Accepted

Solution code:
a = input()
b = input()
if len(a) > len(b):
    print("GREATER")
elif len(b) > len(a):
    print("LESS")
else:
    for i in range(len(a)):
        if a[i] == b[i]:
            continue
        if int(a[i]) > int(b[i]):
            print("GREATER")
            exit()
        else:
            print("LESS")
            exit()
    else:
        print("EQUAL")

Submission status: Accepted

Solution code:
a = input()
b = input()

if len(a)<len(b):
    print("LESS")
elif len(a)>len(b):
    print("GREATER")
elif a<b:
    print("LESS")
elif a>b:
    print("GREATER")
else:
    print("EQUAL")

Submission status: Accepted

Solution code:
A = int(input())
B = int(input())

if A>B:
	print("GREATER")
elif A<B:
	print("LESS")
else:
	print("EQUAL")

Submission status: Accepted

Solution code:
a,b = map(int,[input() for i in range(2)])

if a>b:
    print('GREATER')
if a<b:
    print('LESS')
if a==b:
    print('EQUAL')

Submission status: Accepted

Solution code:
a=int(input())
b=int(input())

if a<b:
  print("LESS")
elif a>b:
  print("GREATER")
else:
  print("EQUAL")

Submission status: Accepted

Solution code:
A = int(input())
B = int(input())

print("GREATER") if A > B else print("LESS") if A < B else print("EQUAL")

Submission status: Accepted

Solution code:
a = input()
b = input()
n = max(len(a),len(b))

b = b.zfill(n)
a = a.zfill(n)

for i in range(n):
  if int(a[i])>int(b[i]):
    print("GREATER")
    exit()
  elif int(a[i])<int(b[i]):
    print("LESS")
    exit()

print("EQUAL")