ZhenlongDai/ACPR huggingface dataset:
Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a=int(input())
b=int(input())
if a>b:
  print('GREATER')
elif b<a:
  print('LESS')
else:
  print('EQUAL')

Failing test case input:
9720246
44989358

Expected output:
LESS


Actual output:
EQUAL


Fixed submission (verdict: Accepted):
a=int(input())
b=int(input())
if a>b:
  print('GREATER')
elif b>a:
  print('LESS')
else:
  print('EQUAL')

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a = input()
b = input()
if a < b:
  print("LESs")
elif a == b:
  print("EQUAL")
else:
  print("GREATER")


Failing test case input:
123456789012345678901234567890
17926279054997782745748552403

Expected output:
GREATER


Actual output:
LESs


Fixed submission (verdict: Accepted):
a = int(input())
b = int(input())
if a < b:
  print("LESS")
elif a == b:
  print("EQUAL")
else:
  print("GREATER")

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a = int(input())
b = int(input())
print('GREATER' if a > b else 'LESS' if b < a else 'EQUAL')


Failing test case input:
36
114

Expected output:
LESS


Actual output:
EQUAL


Fixed submission (verdict: Accepted):
a = int(input())
b = int(input())
print('GREATER' if a > b else 'LESS' if b > a else 'EQUAL')

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a=input()
b=input()
if(a>b):
  print('GREATER')
elif(a==b):
  print('EQUAL')
else:
  print('LESS')

Failing test case input:
850
2564

Expected output:
LESS


Actual output:
GREATER


Fixed submission (verdict: Accepted):
a=int(input())
b=int(input())
if(a>b):
  print('GREATER')
elif(a==b):
  print('EQUAL')
else:
  print('LESS')

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a = int(input())
b = int(input())
if a>b:
  print("GREATER")
else:
  print("LESS")

Failing test case input:
36
36

Expected output:
EQUAL


Actual output:
LESS


Fixed submission (verdict: Accepted):
a = int(input())
b = int(input())
if a>b:
  print("GREATER")
elif a==b:
  print("EQUAL")
else:
  print("LESS")

Problem: p03738
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
a = int(input())
b = int(input())

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

Failing test case input:
36
36

Expected output:
EQUAL


Actual output:
EQUAl


Fixed submission (verdict: Accepted):
a = int(input())
b = int(input())

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

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b=map(int,open(0));print(("GREATER","EQUAL","LESS")[(a==b)+(a<b)])

Failing test case input:
36
62

Expected output:
LESS


Actual output:
EQUAL


Fixed submission (verdict: Accepted):
a,b=map(int,open(0));print(("GREATER","EQUAL","LESS")[(a<=b)+(a<b)])
Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A = input().strip()
B = input().strip()

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

Failing test case input:
123456789012345678901234567890
613957443391671636617596752

Expected output:
GREATER


Actual output:
LESS


Fixed submission (verdict: Accepted):
A = int(input().strip())
B = int(input().strip())

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

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a = int(input())
b = int(input())
if a>b:
  print("GREATER")
elif b<a:
  print("LESS")
else:
  print("EQUAL")

Failing test case input:
123456789012345678901234567890
234567890123456789012345678901

Expected output:
LESS

Actual output:
EQUAL


Fixed submission (verdict: Accepted):
a = int(input())
b = int(input())
if a>b:
  print("GREATER")
elif a<b:
  print("LESS")
else:
  print("EQUAL")

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A = input()
B = input()

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

Failing test case input:
123456789012345678901234567890
17926279054997782745748552403

Expected output:
GREATER


Actual output:
LESS


Fixed submission (verdict: Accepted):
A = int(input())
B = int(input())

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

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A=int(input())
B=int(input())
if A>B:
 print ('greater')
elif A<B:
 print ('less')
else:
 print ('equal')


Failing test case input:
9720246
2197952

Expected output:
GREATER


Actual output:
greater


Fixed submission (verdict: Accepted):
A=int(input())
B=int(input())
if A>B:
 print ('GREATER')
elif A<B:
 print ('LESS')
else:
 print ('EQUAL')

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A = int(input())
B = int(input())
if A>B:
    print("GRATER")
elif A==B:
    print("EQUAL")
else:
    print("LESS")

Failing test case input:
36
6

Expected output:
GREATER


Actual output:
GRATER


Fixed submission (verdict: Accepted):
A = int(input())
B = int(input())
if A>B:
    print("GREATER")
elif A==B:
    print("EQUAL")
else:
    print("LESS")

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a = input()
b = input()
if a < b:
  print("LESS")
elif a == b:
  print("EQUAL")
else:
  print("GREATER")


Failing test case input:
123456789012345678901234567890
15293941696283629404209857104

Expected output:
GREATER


Actual output:
LESS


Fixed submission (verdict: Accepted):
a = int(input())
b = int(input())
if a < b:
  print("LESS")
elif a == b:
  print("EQUAL")
else:
  print("GREATER")
Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A = input()
B = input()

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

Failing test case input:
123456789012345678901234567890
2235567800488482381911156182

Expected output:
GREATER


Actual output:
LESS


Fixed submission (verdict: Accepted):
A = int(input())
B = int(input())

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

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A = int(input())
B = int(input())

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



Failing test case input:
36
36

Expected output:
EQUAL


Actual output:
LESS


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

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a=int(input())
b=int(input())
if a>b:
    print("GREATER")
elif b<a:
    print("LESS")
else:
    print("EQUAL")

Failing test case input:
9720246
14661970

Expected output:
LESS


Actual output:
EQUAL


Fixed submission (verdict: Accepted):
a=int(input())
b=int(input())
if a>b:
    print("GREATER")
elif b>a:
    print("LESS")
else:
    print("EQUAL")

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
MOD=1000000007

def solve():
    a=input()
    b=input()
    if a<b:
        print("LESS")
    elif a>b:
        print("GREATER")
    else:
        print("EQUAL")

if __name__ == "__main__":
    solve()

Failing test case input:
9720246
89020153

Expected output:
LESS


Actual output:
GREATER


Fixed submission (verdict: Accepted):
MOD=1000000007

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

if __name__ == "__main__":
    solve()

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
inp = [input() for i in range(2)]

if (inp[0] > inp[1]):
    print("GREATER")
elif(inp[1] > inp[0]):
    print("LESS")
elif(inp[1] == inp[0]):
    print("EQUAL")

Failing test case input:
123456789012345678901234567890
1334251699597405585061537147

Expected output:
GREATER


Actual output:
LESS


Fixed submission (verdict: Accepted):
inp = [input() for i in range(2)]

A = int(inp[0])
B = int(inp[1])

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

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b=[list(input()) for i in range(2)]
if len(a)>len(b):
  print("GRATER")
elif len(a)<len(b):
  print("LESS")
elif a>b:
  print("GRATER")
elif a<b:
  print("LESS")
else:
  print("EQUAL")

Failing test case input:
850
18

Expected output:
GREATER


Actual output:
GRATER


Fixed submission (verdict: Accepted):
a,b=[list(input()) for i in range(2)]
if len(a)>len(b):
  print("GREATER")
elif len(a)<len(b):
  print("LESS")
elif a>b:
  print("GREATER")
elif a<b:
  print("LESS")
else:
  print("EQUAL")
Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a = int(input())
b = int(input())
print(['LESS', 'GEATER', 'EQUAL'][(a>b)-(a==b)])

Failing test case input:
36
20

Expected output:
GREATER


Actual output:
GEATER


Fixed submission (verdict: Accepted):
a = int(input())
b = int(input())
print(['EQUAL', 'GREATER', 'LESS'][(a>b)-(a<b)])

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A = int(input())
B = int(input())

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


Failing test case input:
36
12

Expected output:
GREATER


Actual output:
GREATER
LESS


Fixed submission (verdict: Accepted):
A = int(input())
B = int(input())

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

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a=int(input())
b=int(input())
if(a>b):
    print("GREATER")
if(a<b):
    print("LESS")
else:
    print("EQUAL")

Failing test case input:
850
22

Expected output:
GREATER


Actual output:
GREATER
EQUAL


Fixed submission (verdict: Accepted):
a=int(input())
b=int(input())
if(a>b):
    print("GREATER")
elif(a<b):
    print("LESS")
else:
    print("EQUAL")

Problem: p03738
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
a=list(input())
b=list(input())
frag="EQUAL"
if len(a)!=len(b):
  if len(a)>len(b):
    frag="GREATER"
  else:
    frag="LESS"
else:
  for i in range(len(a)):
    if a[i]>b[i]:
      frag="GREATER"
      break
    else:
      frag="LESS"
      break
      
print(frag)

Failing test case input:
36
36

Expected output:
EQUAL


Actual output:
LESS


Fixed submission (verdict: Accepted):
a=list(input())
b=list(input())
frag="EQUAL"
if len(a)!=len(b):
  if len(a)>len(b):
    frag="GREATER"
  else:
    frag="LESS"
else:
  for i in range(len(a)):
    if a[i]>b[i]:
      frag="GREATER"
      break
    elif a[i]<b[i]:
      frag="LESS"
      break
      
print(frag)

Problem: p03738
Buggy submission (PyPy3 (7.3.0), verdict: Wrong Answer):
A=int(input())
B=int(input())
if A>B:
	print("GREATER")
elif A<B:
	print("LESSER")
else:
	print("EQUAL")

Failing test case input:
850
4141

Expected output:
LESS


Actual output:
LESSER


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

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A = int(input())
B = int(input())
if A > B:
  print('GREATER')
elif B < A:
  print('LESS')
else:
  print('EQUAL')

Failing test case input:
123456789012345678901234567890
126296095375504287510367096803

Expected output:
LESS


Actual output:
EQUAL


Fixed submission (verdict: Accepted):
A = int(input())
B = int(input())
if A > B:
  print('GREATER')
elif A < B:
  print('LESS')
else:
  print('EQUAL')
Problem: p03738
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
A = int(input())
B = int(input())
if A > B: print("GRATER")
elif A == B: print("EQUAL")
else: print("LESS")  

Failing test case input:
850
5

Expected output:
GREATER


Actual output:
GRATER


Fixed submission (verdict: Accepted):
A = int(input())
B = int(input())
if A > B: print("GREATER")
elif A == B: print("EQUAL")
else: print("LESS")

Problem: p03738
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
a = int(input())
b = int(input())
if a > b:
    print('GRATER')
elif a < b:
    print('LESS')
else:
    print('EQUAL')

Failing test case input:
36
0

Expected output:
GREATER


Actual output:
GRATER


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

Problem: p03738
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
a = input()
b = input()

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

Failing test case input:
123456789012345678901234567890
754112409046425906626365775

Expected output:
GREATER


Actual output:
LESS


Fixed submission (verdict: Accepted):
a = int(input())
b = int(input())

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

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A = input()
B = input()
if A > B:
    print("GREATER")
elif A < B:
    print("LESS")
else:
    print("EQUAL")


Failing test case input:
9720246
38650320

Expected output:
LESS


Actual output:
GREATER


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

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a=int(input())
b=int(input())
print("GREATER" if (a>b) else "LESS" if (a<b) else "equal")

Failing test case input:
36
36

Expected output:
EQUAL


Actual output:
equal


Fixed submission (verdict: Accepted):
a=int(input())
b=int(input())
print("GREATER" if (a>b) else "LESS" if (a<b) else "EQUAL")

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a = int(input())
b = int(input())
if(a > b):
    print("GREATER")
elif(a < b):
    print("LESS")
elif(a == b):
    print("EQUAL")
print(type(a))


Failing test case input:
123456789012345678901234567890
2235567800488482381911156182

Expected output:
GREATER


Actual output:
GREATER
<class 'int'>


Fixed submission (verdict: Accepted):
a = int(input())
b = int(input())
if(a > b):
    print("GREATER")
elif(a < b):
    print("LESS")
elif(a == b):
    print("EQUAL")

Problem: p03738
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
a = input()
b = input()

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

Failing test case input:
123456789012345678901234567890
613957443391671636617596752

Expected output:
GREATER


Actual output:
LESS


Fixed submission (verdict: Accepted):
a = int(input())
b = int(input())


if a>b:
  print('GREATER')
elif a==b:
  print('EQUAL')
else:
  print('LESS')
Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a = input()
b = input()

if len(a)>len(b):
    print('GREATER')
elif len(a)<len(b):
    print('LESS')
else:
    for i in range(0, len(a)):
        if a[i]>b[i]:
            print('GREATER')
            break
        elif a[i]<b[i]:
            print('LESS')
            break
        print('EQUAL')

Failing test case input:
123456789012345678901234567890
161824648859841611049963832583

Expected output:
LESS


Actual output:
EQUAL
LESS


Fixed submission (verdict: Accepted):
a = input()
b = input()

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

Problem: p03738
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
a=input()
b=input()
if a>b:
    print("GREATER")
elif b<a:
    print("LESS")
else:
    print("EQUAL")

Failing test case input:
36
42

Expected output:
LESS


Actual output:
EQUAL


Fixed submission (verdict: Accepted):
a=int(input())
b=int(input())
if a>b:
    print("GREATER")
elif a<b:
    print("LESS")
else:
    print("EQUAL")

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,s=input(),input()
print("GREATER" if a>s else "LESS" if a<s else "EQUAL")

Failing test case input:
850
2564

Expected output:
LESS


Actual output:
GREATER


Fixed submission (verdict: Accepted):
a,s=int(input()),int(input())
print("GREATER" if a>s else "LESS" if a<s else "EQUAL")

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a = input()
b = input()
if a > b:
    print('GREATER')
elif a < b:
    print('LESS')
else:
    print('EQUAL')


Failing test case input:
850
1340

Expected output:
LESS


Actual output:
GREATER


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

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a = int(input())
b = int(input())
if a > b:
  print('GREATER')
elif a == b:
  print('LESS')
else:
  print('EQUAL')

Failing test case input:
36
114

Expected output:
LESS


Actual output:
EQUAL


Fixed submission (verdict: Accepted):
a = int(input())
b = int(input())
if a > b:
  print('GREATER')
elif a == b:
  print('EQUAL')
else:
  print('LESS')

Problem: p03738
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
import sys
input = sys.stdin.readline().strip
a=int(input())
b=int(input())
if a>b:
    print("GREATER")
elif a<b:
    print("LESS")
else:
    print("EQUAL")


Failing test case input:
850
1

Expected output:
GREATER


Actual output:
EQUAL


Fixed submission (verdict: Accepted):
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")
Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):

a = int(input())
b = int(input())

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

Failing test case input:
36
36

Expected output:
EQUAL


Actual output:
LESS


Fixed submission (verdict: Accepted):

a = int(input())
b = int(input())

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

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A = input()
B = input()
if A < B:
    print('LESS')
if A == B:
    print('EQUAL')
if A > B:
    print('GREATER')

Failing test case input:
123456789012345678901234567890
67478580391614097833417622355

Expected output:
GREATER


Actual output:
LESS


Fixed submission (verdict: Accepted):
A = int(input())
B = int(input())
if A < B:
    print('LESS')
if A == B:
    print('EQUAL')
if A > B:
    print('GREATER')

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):

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

Failing test case input:
123456789012345678901234567890
67478580391614097833417622355

Expected output:
GREATER


Actual output:
GRETER


Fixed submission (verdict: Accepted):

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

Problem: p03738
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
A = input()
B = input()
finished = False

if len(A) > len(B):
  print("GREATER")
  finished = True
elif len(A) < len(B):
  print("LESS")
  finished = True
else:
  for i in range(len(A)):
    if A[-i-1] > B[-i-1]:
      print("GREATER")
      finished = True
      break
    elif A[-i-1] < B[-i-1]:
      print("LESS")
      finished = True
      break

if not finished:
  print("EQUAL")


Failing test case input:
36
62

Expected output:
LESS


Actual output:
GREATER


Fixed submission (verdict: Accepted):
A = input()
B = input()
finished = False
 
if len(A) > len(B):
  print("GREATER")
  finished = True
elif len(A) < len(B):
  print("LESS")
  finished = True
else:
  for i in range(len(A)):
    if A[i] > B[i]:
      print("GREATER")
      finished = True
      break
    elif A[i] < B[i]:
      print("LESS")
      finished = True
      break
 
if not finished:
  print("EQUAL")

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A=int(input())
B=int(input())
print('GRATER' if A>B else 'LESS' if A<B else 'EQUAL')
 

Failing test case input:
9720246
1867373

Expected output:
GREATER


Actual output:
GRATER


Fixed submission (verdict: Accepted):
A=int(input())
B=int(input())
print('GREATER' if A>B else 'LESS' if A<B else 'EQUAL')
Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a = input()
b = input()
c = len(a)
d = len(b)
if c>d:
    print('GREATER')
elif c<d:
    print('LESS')
else:
    for x, y in zip(a,b):
        if x<y:
            print('LESS')
            exit()
        if x>y:
            print('GREATER')
            exit()
    print('EVEN')

Failing test case input:
36
36

Expected output:
EQUAL


Actual output:
EVEN


Fixed submission (verdict: Accepted):
a = input()
b = input()
c = len(a)
d = len(b)
if c>d:
    print('GREATER')
elif c<d:
    print('LESS')
else:
    for x, y in zip(a,b):
        if x<y:
            print('LESS')
            exit()
        if x>y:
            print('GREATER')
            exit()
    print('EQUAL')

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A = input()
B = input()
print('LESS') if A<B else print('GREATER') if A>B else print('EQUAL')

Failing test case input:
123456789012345678901234567890
12740860331988085550751547536

Expected output:
GREATER


Actual output:
LESS


Fixed submission (verdict: Accepted):
A = input()
B = input()
tmp = max(len(A),len(B))

A = A.zfill(tmp)
B = B.zfill(tmp)
print('LESS') if A<B else print('GREATER') if A>B else print('EQUAL')

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A=int(input())
B=int(input())
if A>B:
    print("GREATER")
elif A==B:
    print("LESS")
else:
    print("EQUAL")

Failing test case input:
9720246
169922301

Expected output:
LESS


Actual output:
EQUAL


Fixed submission (verdict: Accepted):
A=int(input())
B=int(input())
if A>B:
    print("GREATER")
elif A==B:
    print("EQUAL")
else:
    print("LESS")

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A=input()
B=input()
a=len(A)
b=len(B)
if a>b:
  print("GRATER")
elif b>a:
  print("LESS")
else:
  i=0
  while i<a:
    if A[i]>B[i]:
      print("GRATER")
      break
    elif B[i]>A[i]:
      print("LESS")
      break
    else:
      i=i+1
      if i==a:
        print("EQUAL")

Failing test case input:
36
-2

Expected output:
GREATER


Actual output:
GRATER


Fixed submission (verdict: Accepted):
A=input()
B=input()
a=len(A)
b=len(B)
if a>b:
  print("GREATER")
elif b>a:
  print("LESS")
else:
  i=0
  while i<a:
    if A[i]>B[i]:
      print("GREATER")
      break
    elif B[i]>A[i]:
      print("LESS")
      break
    else:
      i=i+1
      if i==a:
        print("EQUAL")

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a = input()
b = input()
if a == b:
    print('EQUAL')
elif a < b:
    print('LESS')
else:
    print('GREATER')

Failing test case input:
123456789012345678901234567890
12740860331988085550751547536

Expected output:
GREATER


Actual output:
LESS


Fixed submission (verdict: Accepted):
a = int(input())
b = int(input())
if a == b:
    print('EQUAL')
elif a < b:
    print('LESS')
else:
    print('GREATER')
Problem: p03738
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
A = int(input())
B = int(input())
if A > B:
  print('GRATER')
elif A == B:
  print('EQUAL')
else:
  print('LESS')

Failing test case input:
850
-2

Expected output:
GREATER


Actual output:
GRATER


Fixed submission (verdict: Accepted):
A = int(input())
B = int(input())
if A - B > 0:
  print('GREATER')
elif A - B == 0:
  print('EQUAL')
else:
  print('LESS')

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a=input()
b=input()
if a>b:
    print("GREATER")
elif a<b:
    print("LESS")
else:
    print("EQUAL")

Failing test case input:
9720246
169922301

Expected output:
LESS


Actual output:
GREATER


Fixed submission (verdict: Accepted):
a=int(input())
b=int(input())
if a>b:
    print("GREATER")
elif a<b:
    print("LESS")
else:
    print("EQUAL")

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A = int(input())
B = int(input())

print(A)

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

Failing test case input:
9720246
520749

Expected output:
GREATER


Actual output:
9720246
GREATER


Fixed submission (verdict: Accepted):
A = int(input())
B = int(input())

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

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a = int(input())
b = int(input())
if a < b:
  print("LESS")
else:
  print("GREATER")  

Failing test case input:
36
36

Expected output:
EQUAL


Actual output:
GREATER


Fixed submission (verdict: Accepted):
a = int(input())
b = int(input())
if a < b:
  print("LESS")
elif a > b:
  print("GREATER")
else:
  print("EQUAL")

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):

A = int(input())
B = int(input())

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


Failing test case input:
36
36

Expected output:
EQUAL


Actual output:
EQUAl


Fixed submission (verdict: Accepted):
A = int(input())
B = int(input())

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

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a=int(input())
b=int(input())

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

Failing test case input:
36
36

Expected output:
EQUAL


Actual output:
GREATER


Fixed submission (verdict: Accepted):
a=int(input())
b=int(input())

if a>b:
    print('GREATER')
elif a<b:
    print('LESS')
else:
    print('EQUAL')
Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A = input()
B = input()
if len(A) > len(B):
  print("GREATER")
elif len(B) < len(A):
  print("LESS")
else:
  if A > B:
    print("GREATER")
  elif B < A:
    print("LESS")
  else:
    print("EQUAL")
  

Failing test case input:
123456789012345678901234567890
161824648859841611049963832583

Expected output:
LESS


Actual output:
EQUAL


Fixed submission (verdict: Accepted):
A = input()
B = input()
if A == B:
  print("EQUAL")
else:
  if len(A) > len(B):
    print("GREATER")
  elif len(B) > len(A):
    print("LESS")
  else:
    if A > B:
      print("GREATER")
    else:
      print("LESS")

Problem: p03738
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
a = int(input())
b = int(input())
if a < b:
  print("LESS")
elif a > b:
  print("GREATER")
else:
  print("EQUAl")

Failing test case input:
36
36

Expected output:
EQUAL


Actual output:
EQUAl


Fixed submission (verdict: Accepted):
a = int(input())
b = int(input())
if a < b:
  print("LESS")
elif a > b:
  print("GREATER")
else:
  print("EQUAL")

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):


A = input()
B = input()

if A>B:
    ans = 'GREATER'
elif A<B:
    ans = 'LESS'
elif A==B:
    ans = 'EQUAL'

print(ans)

Failing test case input:
850
3777

Expected output:
LESS

Actual output:
GREATER


Fixed submission (verdict: Accepted):


A = int(input())
B = int(input())

if A>B:
    ans = 'GREATER'
elif A<B:
    ans = 'LESS'
elif A==B:
    ans = 'EQUAL'

print(ans)

Problem: p03738
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
A = int(input())
B = int(input())
if A - B > 0:
  print('GRATER')
elif A - B == 0:
  print('EQUAL')
else:
  print('LESS')

Failing test case input:
850
4

Expected output:
GREATER


Actual output:
GRATER


Fixed submission (verdict: Accepted):
A = int(input())
B = int(input())
if A - B > 0:
  print('GREATER')
elif A - B == 0:
  print('EQUAL')
else:
  print('LESS')

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a = input()
b = input()

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

Failing test case input:
36
191

Expected output:
LESS


Actual output:
GREATER


Fixed submission (verdict: Accepted):
a = int(input())
b = int(input())

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

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):


A = int(input())
B = int(input())

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


Failing test case input:
36
-4

Expected output:
GREATER


Actual output:
GRATER


Fixed submission (verdict: Accepted):


A = int(input())
B = int(input())

if A > B:
    print('GREATER')
elif B > A:
    print('LESS')
else:
    print('EQUAL')
Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a = int(input())
b = int(input())

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

Failing test case input:
36
36

Expected output:
EQUAL


Actual output:
LESS


Fixed submission (verdict: Accepted):
a = int(input())
b = int(input())

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

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a=int(input())
b=int(input())
if a>b:
	print("GREATER")
elif a==b:
	print("LESS")
else:
	print("EQUAL")

Failing test case input:
36
46

Expected output:
LESS


Actual output:
EQUAL


Fixed submission (verdict: Accepted):
a=int(input())
b=int(input())
if a>b:
	print("GREATER")
elif a<b:
	print("LESS")
else:
	print("EQUAL")

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n1 = input()
n2 = input()
if n1 < n2:
    print("LESS")
elif n1 > n2:
    print('GREATER')
else:
    print('EQUAL')

Failing test case input:
123456789012345678901234567890
67478580391614097833417622355

Expected output:
GREATER


Actual output:
LESS


Fixed submission (verdict: Accepted):
n1 = int(input())
n2 = int(input())
if n1 < n2:
    print("LESS")
elif n1 > n2:
    print('GREATER')
else:
    print('EQUAL')

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a = int(input())
b = int(input())
if a<b:
    print("LESS")
elif a==b:
    print("EQUAL")
else:
    print("GRATER")

Failing test case input:
36
0

Expected output:
GREATER


Actual output:
GRATER


Fixed submission (verdict: Accepted):
a = int(input())
b = int(input())
if a<b:
    print("LESS")
elif a==b:
    print("EQUAL")
else:
    print("GREATER")

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A,B=input(),input()
print("GREATER" if A>B else "LESS" if A<B else "EQUAL")

Failing test case input:
123456789012345678901234567890
17748575717002983456224641477

Expected output:
GREATER


Actual output:
LESS


Fixed submission (verdict: Accepted):
A,B=int(input()),int(input())
print("GREATER" if A>B else "LESS" if A<B else "EQUAL")

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a=int(input())
b=int(input())
if a>b:
    print('GRETER')
elif a<b:
    print('LESS')
else:
    print('EQUAL')

Failing test case input:
36
13

Expected output:
GREATER


Actual output:
GRETER


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

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a=int(input())
b=int(input())
print("GREATER" if a>b else "LESS" if b<a else "EQUAL")

Failing test case input:
9720246
44989358

Expected output:
LESS


Actual output:
EQUAL


Fixed submission (verdict: Accepted):
a=int(input())
b=int(input())
print("GREATER" if a>b else "LESS" if b>a else "EQUAL")
Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a = int(input())
b = int(input())

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


Failing test case input:
36
36

Expected output:
EQUAL


Actual output:
LESS


Fixed submission (verdict: Accepted):
a = int(input())
b = int(input())

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

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a = input()
b = input()
print(['LESS', 'GEATER', 'EQUAL'][(a>b)-(a==b)])

Failing test case input:
36
23

Expected output:
GREATER


Actual output:
GEATER


Fixed submission (verdict: Accepted):
a = int(input())
b = int(input())
print(['EQUAL', 'GREATER', 'LESS'][(a>b)-(a<b)])

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A = input()
B = input()

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

Failing test case input:
850
1340

Expected output:
LESS


Actual output:
GREATER


Fixed submission (verdict: Accepted):
A = int(input())
B = int(input())

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

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a = input()
b = input()
ret = ""
if len(a) > len(b):
    ret = "GREATER"
elif len(a) < len(b):
    ret = "LESS"
else:
    for (i, c) in enumerate(a):
        if(c > b[i]):
            ret = "GREATER"
            break
        elif len(a) < len(b):
            ret = "LESS"
            break
        else:
            pass
if ret == "":
    print("EQUAL")
else:
    print(ret)


Failing test case input:
123456789012345678901234567890
179827845276187955292784642083

Expected output:
LESS


Actual output:
GREATER


Fixed submission (verdict: Accepted):
a = input()
b = input()
ret = ""
if len(a) > len(b):
    ret = "GREATER"
elif len(a) < len(b):
    ret = "LESS"
else:
    for (i, c) in enumerate(a):
        if(c > b[i]):
            ret = "GREATER"
            break
        elif(c < b[i]):
            ret = "LESS"
            break
        else:
            pass
if ret == "":
    print("EQUAL")
else:
    print(ret)

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a =int(input())
b =int(input())
if a>b:print('GREATER')
elif b<a:print('LESS')
else:print('EQUAL')


Failing test case input:
9720246
44989358

Expected output:
LESS


Actual output:
EQUAL


Fixed submission (verdict: Accepted):
a = int(input())
b = int(input())
if a>b:print('GREATER')
elif b>a:print('LESS')
else:print('EQUAL')

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a = int(input())
b = int(input())

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


Failing test case input:
36
114

Expected output:
LESS


Actual output:

Fixed submission (verdict: Accepted):
a = int(input())
b = int(input())

if a>b :
    print("GREATER")
elif a<b:
    print("LESS")
elif a == b:
    print("EQUAL")
Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a = int(input())
b = int(input())

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

Failing test case input:
36
36

Expected output:
EQUAL


Actual output:
EUQAL


Fixed submission (verdict: Accepted):
a = int(input())
b = int(input())

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

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a = input()
b = input()
if(a > b):
    print("GRATER")
elif(a < b):
    print("LESS")
elif(a == b):
    print("EQUAL")


Failing test case input:
850
6

Expected output:
GREATER


Actual output:
GRATER


Fixed submission (verdict: Accepted):
a = int(input())
b = int(input())
if(a > b):
    print("GREATER")
elif(a < b):
    print("LESS")
elif(a == b):
    print("EQUAL")

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a = int(input())
b = int(input())
if a == b:
    print("EQUAL")
elif a > b:
    print("GREATER")
else:
    print("GREATER")

Failing test case input:
36
50

Expected output:
LESS


Actual output:
GREATER


Fixed submission (verdict: Accepted):
a = int(input())
b = int(input())
if a == b:
    print("EQUAL")
elif a > b:
    print("GREATER")
else:
    print("LESS")

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a = input()
b = input() 
if len(a) < len(b):
  print("LESS")
  exit()
elif len(a) > len(b):
  print("GREATER")
  exit()
else:
  for i in range(len(a)):
    if a[i] > b[i]:
      print("GREATER")
      exit()
    elif a[i] < b[i]:
      print("LESS")
print("EQUAL")

Failing test case input:
123456789012345678901234567890
179827845276187955292784642083

Expected output:
LESS


Actual output:
LESS
LESS
LESS
GREATER


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

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A = int(input())
B = int(input())

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


Failing test case input:
36
23

Expected output:
GREATER


Actual output:
GEATER


Fixed submission (verdict: Accepted):
A = int(input())
B = int(input())

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

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a=input().split()
b=input().split()
print("GREATER" if a>b else "LESS")

Failing test case input:
9720246
89020153

Expected output:
LESS


Actual output:
GREATER


Fixed submission (verdict: Accepted):
a=int(input())
b=int(input())
print("GREATER" if a>b else "LESS" if a<b else "EQUAL")
Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a = input()
b = input()
if(a > b):
    print("GREATER")
elif(a < b):
    print("LESS")
elif(a == b):
    print("EQUAL")

Failing test case input:
123456789012345678901234567890
17926279054997782745748552403

Expected output:
GREATER


Actual output:
LESS


Fixed submission (verdict: Accepted):
a = int(input())
b = int(input())
if(a > b):
    print("GREATER")
elif(a < b):
    print("LESS")
elif(a == b):
    print("EQUAL")

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
from sys import exit
A = input()
B = input()
if len(A) > len(B):
  print("GREATER")
elif len(A) < len(B):
  print("LESS")
else:
  for a,b in zip(A,B):
    if a > b:
      print("GREATER")
      exit()
    elif a < b:
      print("LESS")
      exit()
print("EQUAL")

Failing test case input:
9720246
38650320

Expected output:
LESS


Actual output:
LESS
EQUAL


Fixed submission (verdict: Accepted):
from sys import exit
A = input()
B = input()
if len(A) > len(B):
  print("GREATER")
elif len(A) < len(B):
  print("LESS")
else:
  for a,b in zip(A,B):
    if a > b:
      print("GREATER")
      exit()
    elif a < b:
      print("LESS")
      exit()
  print("EQUAL")

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A=int(input())
B=int(input())

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

Failing test case input:
36
62

Expected output:
LESS


Actual output:
EQUAL


Fixed submission (verdict: Accepted):
A=int(input())
B=int(input())

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

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
def main():
    A = int(input())
    B = int(input())

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

if __name__ == "__main__":
    main()


Failing test case input:
9720246
89020153

Expected output:
LESS


Actual output:
EQUAL


Fixed submission (verdict: Accepted):
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()

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a=input()
b=input()
if len(a)==len(b):
  if a>b:
    print("GREATER")
  elif a<b:
    print("LESS")
  else :
    print("EQUAL")
else :
  if len(a)>len(b):
    print("greater")
  else:
    print("less")

Failing test case input:
9720246
716544

Expected output:
GREATER


Actual output:
greater


Fixed submission (verdict: Accepted):
a=input()
b=input()
if len(a)==len(b):
  if a>b:
    print("GREATER")
  elif a<b:
    print("LESS")
  else :
    print("EQUAL")
else :
  if len(a)>len(b):
    print("GREATER")
  else:
    print("LESS")
Problem: p03738
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
a=input()
b=input()

if len(a)<len(b):
    print('LESS')
elif len(a)>len(b):
    print('GREATER')
else:
    for i in range(len(a)):
        if a[i]>b[i]:
            print('GREATER')
            break
        elif a[i]<b[i]:
            print('LESS')
            break
        else:
            continue

Failing test case input:
36
36

Expected output:
EQUAL


Actual output:

Fixed submission (verdict: Accepted):
a=input()
b=input()

if len(a)<len(b):
    print('LESS')
elif len(a)>len(b):
    print('GREATER')
else:
    f=0
    for i in range(len(a)):
        if a[i]>b[i]:
            print('GREATER')
            break
        elif a[i]<b[i]:
            print('LESS')
            break
        else:
            f+=1
            continue
    if f==len(a):
        print('EQUAL')

Problem: p03738
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
a=input()
b=input()
if a>b:
    print("GREATER")
elif a<b:
    print("LESS")
else:
    print("EQUAL")

Failing test case input:
123456789012345678901234567890
2235567800488482381911156182

Expected output:
GREATER


Actual output:
LESS


Fixed submission (verdict: Accepted):
a=int(input())
b=int(input())
if a>b:
    print("GREATER")
elif a<b:
    print("LESS")
else:
    print("EQUAL")

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
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
        if i == len(A):
            print("EQUAL")

Failing test case input:
36
36

Expected output:
EQUAL


Actual output:

Fixed submission (verdict: Accepted):
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
        if i == len(A)-1:
            print("EQUAL")

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A = input()
B = input()

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

Failing test case input:
9720246
169922301

Expected output:
LESS


Actual output:
GREATER


Fixed submission (verdict: Accepted):
A = int(input())
B = int(input())

if A == B:
  print('EQUAL')
elif A < B:
  print('LESS')
else:
  print('GREATER')
Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
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

Failing test case input:
36
36

Expected output:
EQUAL


Actual output:

Fixed submission (verdict: Accepted):
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")
			exit()
		elif a[i] < b[i]:
			print("LESS")
			exit()
	print("EQUAL")

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a = int(input())
b = int(input())

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


Failing test case input:
36
36

Expected output:
EQUAL


Actual output:
LESS


Fixed submission (verdict: Accepted):
a = int(input())
b = int(input())

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

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A = input()
B = input()

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

Failing test case input:
9720246
51961997

Expected output:
LESS


Actual output:
GREATER


Fixed submission (verdict: Accepted):
A = int(input())
B = int(input())

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

Problem: p03738
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
A = int(input())
B = int(input())
if A > B:
  print('GRATER')
elif A < B:
  print('LESS')
else:
  print('EQUAL')

Failing test case input:
123456789012345678901234567890
2235567800488482381911156182

Expected output:
GREATER


Actual output:
GRATER


Fixed submission (verdict: Accepted):
A = int(input())
B = int(input())
if A > B:
  print('GREATER')
elif A < B:
  print('LESS')
else:
  print('EQUAL')

Problem: p03738
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
a = int(input())
b = int(input())
if a >b:
  print('GREATER')
else:
  print('LESS')

Failing test case input:
36
36

Expected output:
EQUAL


Actual output:
LESS


Fixed submission (verdict: Accepted):
a = int(input())
b = int(input())
if a >b:
  print('GREATER')
elif a== b:
  print('EQUAL')
else:
  print('LESS')

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
def main():
    a = int(input())
    b = int(input())

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


if __name__ == "__main__":

    main()


Failing test case input:
123456789012345678901234567890
128418069768106242638679140

Expected output:
GREATER


Actual output:
GRATER


Fixed submission (verdict: Accepted):
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()
Problem: p03738
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
a = input()
b = input()

def solve(a,b,n,i):
    if n == i:
        return(print("EQUAL"))
    if a[i] >b[i]:
        print("GREATER")
    elif b[i]>a[i]:
        print("LESS")
    else:
        solve(a,b,n,i+1)

if len(a)>len(b):
    print("GREATER")
elif len(b)>len(b):
    print("LESS")
else:
    solve(a,b,len(a),0)


Failing test case input:
850
2564

Expected output:
LESS


Actual output:
GREATER


Fixed submission (verdict: Accepted):
a = input()
b = input()

def solve(a,b,n,i):
    if n == i:
        return(print("EQUAL"))
    if a[i] >b[i]:
        print("GREATER")
    elif b[i]>a[i]:
        print("LESS")
    else:
        solve(a,b,n,i+1)

if len(a)>len(b):
    print("GREATER")
elif len(b)>len(a):
    print("LESS")
else:
    solve(a,b,len(a),0)

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A = int(input())
B = int(input())

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

else:
	print('LESS')

Failing test case input:
123456789012345678901234567890
1119902891660531144210274801

Expected output:
GREATER


Actual output:
GREATER
LESS


Fixed submission (verdict: Accepted):
A = int(input())
B = int(input())

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

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a = input()
b = input()
a > b and "GREATER" or (a == b and "EQUAL" or "LESS")

Failing test case input:
850
-8

Expected output:
GREATER


Actual output:

Fixed submission (verdict: Accepted):
a = int(input())
b = int(input()) 
print(a > b and "GREATER" or (a == b and "EQUAL" or "LESS"))

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a = input()
b = input()
print(a > b and "GREATER" or (a == b and "EQUAL" or "LESS"))

Failing test case input:
850
2564

Expected output:
LESS


Actual output:
GREATER


Fixed submission (verdict: Accepted):
a = int(input())
b = int(input()) 
print(a > b and "GREATER" or (a == b and "EQUAL" or "LESS"))

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a=input()
b=input()

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

Failing test case input:
36
23

Expected output:
GREATER


Actual output:
EQUAL


Fixed submission (verdict: Accepted):
a=int(input())
b=int(input())

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

Problem: p03738
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A = int(input())
B = int(input())
if A > B:
    print("GREADER")
elif A == B:
    print("EQUAL")
else:
    print("LESS")


Failing test case input:
9720246
839774

Expected output:
GREATER


Actual output:
GREADER


Fixed submission (verdict: Accepted):
A = int(input())
B = int(input())
if A > B:
    print("GREATER")
elif A == B:
    print("EQUAL")
else:
    print("LESS")