ZhenlongDai/ACPR huggingface dataset:
Problem: p03657
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b = map(int,input().split())
print("Possible" if (a+b)%3 == 0 else "Impossible")


Failing test case input:
-3 40

Expected output:
Possible


Actual output:
Impossible


Fixed submission (verdict: Accepted):
a,b = map(int,input().split())
print("Possible" if a%3 == 0 or b%3 == 0 or (a+b)%3 == 0 else "Impossible")

Problem: p03657
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
a,b=map(int,input().split())
if a%3==0 or b%3==0 or a+b%3==0:
  print("Possible")
else:
  print("Impossible")

Failing test case input:
7 -4

Expected output:
Possible


Actual output:
Impossible


Fixed submission (verdict: Accepted):
a,b=map(int,input().split())
if a%3==0 or b%3==0 or (a+b)%3==0:
  print("Possible")
else:
  print("Impossible")

Problem: p03657
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b=map(int,input().split())
if a%3 or b%3 or (a+b)%3:
    print('Impossible')
else: print('Possible')
    

Failing test case input:
-3 40

Expected output:
Possible


Actual output:
Impossible


Fixed submission (verdict: Accepted):
a,b=map(int,input().split())
print('Impossible' if a%3 and b%3 and (a+b)%3 else 'Possible')

Problem: p03657
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b = map(int, input().split())
print('Possible' if (a+b)%3==0 else 'Impossible')

Failing test case input:
-5 -18

Expected output:
Possible


Actual output:
Impossible


Fixed submission (verdict: Accepted):
a, b = map(int, input().split())
print('Possible' if a%3==0 or b%3==0 or (a+b)%3==0 else 'Impossible')

Problem: p03657
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b=map(int,input().split())
if a%3==0 or b%3==0 or a+b%3==0:
    print("Possible")
else:
    print("Impossible")

Failing test case input:
-13 4

Expected output:
Possible


Actual output:
Impossible


Fixed submission (verdict: Accepted):
a,b=map(int,input().split())
if a%3==0 or b%3==0 or (a+b)%3==0:
    print("Possible")
else:
    print("Impossible")

Problem: p03657
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A, B = map(int, input().split())
if A % 3 or B % 3 or (A+B) % 3 == 0:
    print("Possible")
else:
    print("Impossible")

Failing test case input:
-8 4

Expected output:
Impossible


Actual output:
Possible


Fixed submission (verdict: Accepted):
A, B = map(int, input().split())
if A % 3 == 0 or B % 3 == 0 or (A+B) % 3 == 0:
    print("Possible")
else:
    print("Impossible")

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



x=input()
a=int(x.split(" ")[0])
b=int(x.split(" ")[1])
if (a%3 or b%3 or (a+b)%3):
    print ("Possible")
else:
    print ("Impossible")



Failing test case input:
5 -4

Expected output:
Impossible


Actual output:
Possible


Fixed submission (verdict: Accepted):


 
x=input()
a=int(x.split(" ")[0])
b=int(x.split(" ")[1])
if (a%3==0 or b%3==0 or (a+b)%3==0):
    print ("Possible")
else:
    print ("Impossible")
Problem: p03657
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
import sys

a, b = map(int, sys.stdin.readline().split())

if a % 3 == 0 or b % 3 == 0 or a + b % 3 == 0:
    print("Possible")
else:
    print("Impossible")

Failing test case input:
7 -4

Expected output:
Possible


Actual output:
Impossible


Fixed submission (verdict: Accepted):
import sys

a, b = map(int, sys.stdin.readline().split())

if a % 3 == 0 or b % 3 == 0 or (a + b) % 3 == 0:
    print("Possible")
else:
    print("Impossible")

Problem: p03657
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b=map(int,input().split())
print("Possible" if (a+b)%3==0 else "Impossible")

Failing test case input:
-3 40

Expected output:
Possible


Actual output:
Impossible


Fixed submission (verdict: Accepted):
a,b=map(int,input().split())
print("Possible" if (a%3==0) or (b%3==0) or((a+b)%3==0) else "Impossible")

Problem: p03657
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b = map(int,input().split())
if a % 3 or b % 3 or a+b %3 == 0:
  print('Possible')
else:
  print('Impossible')

Failing test case input:
5 -4

Expected output:
Impossible


Actual output:
Possible


Fixed submission (verdict: Accepted):
a, b = map(int,input().split())
if (a % 3 == 0) or (b % 3 == 0) or ((a+b) %3 == 0):
  print('Possible')
else:
  print('Impossible')

Problem: p03657
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b  = map(int,input().split())

if (a % 3 != 0) and ( b % 3 != 0):
  print("Impossible")
  
else:
  print("Possible")
  

Failing test case input:
7 -4

Expected output:
Possible


Actual output:
Impossible


Fixed submission (verdict: Accepted):
a, b  = map(int,input().split())

if (a % 3 == 0) or( b % 3 == 0) or ((a + b) % 3 ==0):
  print("Possible")
  
else:
  print("Impossible")

Problem: p03657
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
m, n = map(int, input().split())
ans = (m + n) % 3
if ans == 0:
    print("Possible")
else:
    print("Impossible")


Failing test case input:
-5 -18

Expected output:
Possible


Actual output:
Impossible


Fixed submission (verdict: Accepted):
m, n = map(int, input().split())
ans = (m + n) % 3
ans2 = m % 3
ans3 = n % 3
if ans == 0 or ans2 == 0 or ans3 == 0:
    print("Possible")
else:
    print("Impossible")

Problem: p03657
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
a, b = map(int, input().split())
x = a + b
if x % 3 == 0:
  print('Possible')
else:
  print('Impossidle')


Failing test case input:
5 -4

Expected output:
Impossible


Actual output:
Impossidle


Fixed submission (verdict: Accepted):
a, b = map(int, input().split())
if (a + b) % 3 == 0 or b % 3 == 0 or a % 3 == 0:
    print("Possible")
else:
    print("Impossible")

Problem: p03657
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b=map(int,input().split())
if a%3==0 or b&3==0 or (a+b)%3==0:
  print("Possible")
else:
  print("Impossible")

Failing test case input:
-5 -6

Expected output:
Possible


Actual output:
Impossible


Fixed submission (verdict: Accepted):
A,B=map(int,input().split())
if A%3==0 or B%3==0 or (A+B)%3==0:
    print('Possible')
else:
    print('Impossible')
Problem: p03657
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b = list(map(int, input().split()))
if a%3 ==0 or b%3==0 or a+b%3==0:
  print("Possible")
else:
  print("Impossible")

Failing test case input:
-13 4

Expected output:
Possible


Actual output:
Impossible


Fixed submission (verdict: Accepted):
a,b = list(map(int, input().split()))
if a%3 ==0 or b%3==0 or (a+b)%3==0:
  print("Possible")
else:
  print("Impossible")

Problem: p03657
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A,B=map(int,input().split())
print('Possible' if (A+B)%3 == 0 else 'Impossible')


Failing test case input:
-2 81

Expected output:
Possible


Actual output:
Impossible


Fixed submission (verdict: Accepted):
A,B=map(int,input().split())
print('Possible' if (A+B)%3 == 0 or A%3 == 0 or B%3 == 0 else 'Impossible')

Problem: p03657
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A, B = list(map(int,input().split()))
if A + B % 3 == 0:
  print("Possible")
else:
  print("Impossible")

Failing test case input:
15 -3

Expected output:
Possible


Actual output:
Impossible


Fixed submission (verdict: Accepted):
A, B = list(map(int,input().split()))
if A % 3 ==0 or B % 3 ==0 or (A + B) % 3 == 0:
  print("Possible")
else:
  print("Impossible")

Problem: p03657
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b = map(int, input().split())
print("Possible" if a+b%3 == 0 or a%3==0 or b%3==0 else "Impossible")

Failing test case input:
-13 4

Expected output:
Possible


Actual output:
Impossible


Fixed submission (verdict: Accepted):
a, b = map(int, input().split())
print("Possible" if (a+b)%3 == 0 or a%3==0 or b%3==0 else "Impossible")

Problem: p03657
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A,B = [int(i) for i in input().split(" ")]
if (A+B) % 3 == 0 :
    print("Possible")
else:
    print("Impossible")


Failing test case input:
-5 -18

Expected output:
Possible


Actual output:
Impossible


Fixed submission (verdict: Accepted):
A,B = [int(i) for i in input().split(" ")]
if (A+B) % 3 == 0 or A % 3 == 0 or B % 3 == 0:
    print("Possible")
else:
    print("Impossible")

Problem: p03657
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
a,b=map(int,input().split())
print('Possible' if a%3==0 or b%3==0 or a+b&3==0 else 'Impossible')

Failing test case input:
-8 4

Expected output:
Impossible


Actual output:
Possible


Fixed submission (verdict: Accepted):
a,b=map(int,input().split())
print('Possible' if a%3==0 or b%3==0 or (a+b)%3==0 else 'Impossible')

Problem: p03657
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b= map(int,input().split())
print('Possible' if (a+b)%3==0 else 'Impossible')

Failing test case input:
-5 -6

Expected output:
Possible


Actual output:
Impossible


Fixed submission (verdict: Accepted):
a,b= map(int,input().split())
print('Possible' if (a+b)%3==0 or a%3==0 or b%3==0 else 'Impossible')
Problem: p03657
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
a,b = map(int, input().split())
print("Possible" if (a+b)%3==0 else "Impossible")

Failing test case input:
-5 -18

Expected output:
Possible


Actual output:
Impossible


Fixed submission (verdict: Accepted):
a,b = map(int, input().split())
print("Possible" if a%3==0 or b%3==0 or (a+b)%3==0 else "Impossible")

Problem: p03657
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A,B=map(int,input().split())
print('Possible' if (A+B)%3==0 else 'Impossible')


Failing test case input:
-5 -18

Expected output:
Possible


Actual output:
Impossible


Fixed submission (verdict: Accepted):
A,B=map(int,input().split())
if A%3==0 or B%3==0 or (A+B)%3==0:
    print('Possible')
else:
    print('Impossible')

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

import sys
input = sys.stdin.readline

a, b = map(int, input().split())
if (a*b)%3 == 0 or a%3 == 0 or b%3 == 0:
    ans = 'Possible'
else:
    ans = 'Impossible'
print(ans)

Failing test case input:
-13 4

Expected output:
Possible


Actual output:
Impossible


Fixed submission (verdict: Accepted):

import sys
input = sys.stdin.readline

a, b = map(int, input().split())
if (a+b)%3 == 0 or a%3 == 0 or b%3 == 0:
    ans = 'Possible'
else:
    ans = 'Impossible'
print(ans)

Problem: p03657
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A,B=map(int,input().split())
if (((A+B)%3)==0):
    print ("Possible")
else:
    print ("Impossible")

Failing test case input:
-5 -18

Expected output:
Possible


Actual output:
Impossible


Fixed submission (verdict: Accepted):
A,B=map(int,input().split())
if (A%3==0 or B%3==0 or (A+B)%3==0):
    print ("Possible")
else:
    print ("Impossible")

Problem: p03657
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
a, b = map(int, input().split())

if a + b == (a + b) % 3 == 0:
    print("Possible")
else:
    print("Impossible")

Failing test case input:
15 -3

Expected output:
Possible


Actual output:
Impossible


Fixed submission (verdict: Accepted):
a, b = map(int, input().split())

if (a + b) % 3 == 0 or b % 3 == 0 or a % 3 == 0:
    print("Possible")
else:
    print("Impossible")

Problem: p03657
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b = input().split()
a, b = int(a), int(b)
if (a + b) % 3 == 0:
  print("Possible")
else:
  print("Impossible")

Failing test case input:
-3 40

Expected output:
Possible


Actual output:
Impossible


Fixed submission (verdict: Accepted):
a, b = input().split()
a, b = int(a), int(b)
if (a + b) % 3 == 0 or a % 3 == 0 or b % 3 == 0:
  print("Possible")
else:
  print("Impossible")

Problem: p03657
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
a,b = map(int,input().split())
if a%3==0 or b%3==0 or (a+b)%3==0:
  print('Possible')
else:
  print('Imossible')

Failing test case input:
-8 4

Expected output:
Impossible


Actual output:
Imossible


Fixed submission (verdict: Accepted):
a,b = map(int,input().split())
if a%3==0 or b%3==0 or (a+b)%3==0:
  print('Possible')
else:
  print('Impossible')
Problem: p03657
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
A, B = map(int, input().split())

if (A+B) % 2 != 0:
    print('Possible')
else:
    print('Impossible')

Failing test case input:
15 -3

Expected output:
Possible


Actual output:
Impossible


Fixed submission (verdict: Accepted):
A, B = map(int, input().split())

if A % 3 == 0 or B % 3 == 0 or(A+B) % 3 == 0:
    print('Possible')
else:
    print('Impossible')

Problem: p03657
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
a, b = map(int, input().split())
if (a + b) % 3 == 0:
  print("Possible")
else:
  print("Impossible")

Failing test case input:
-4 -18

Expected output:
Possible


Actual output:
Impossible


Fixed submission (verdict: Accepted):
a, b = map(int, input().split())
print("Possible" if a % 3 == 0 or b % 3 == 0 or (a + b) % 3 == 0 else "Impossible")

Problem: p03657
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A,B = map(int,input().split())

if A+B < 3:
    print('Impossible') 
elif (A+B)%3 == 0:
    print('Possible')
else:
    print('Impossible')

Failing test case input:
-5 -18

Expected output:
Possible


Actual output:
Impossible


Fixed submission (verdict: Accepted):
A,B = map(int,input().split())

if A%3==0 or B%3==0 or (A+B)%3 == 0:
    print('Possible')
else:
    print('Impossible')

Problem: p03657
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b = [int(i) for i in input().split()]
if a % 3 == 0 or b % 3 == 0 or a + b % 3 == 0:
    print("Possible")
else:
    print("Imposible")

Failing test case input:
-8 4

Expected output:
Impossible


Actual output:
Imposible


Fixed submission (verdict: Accepted):
a, b = [int(i) for i in input().split()]
if a % 3 == 0 or b % 3 == 0 or (a + b) % 3 == 0:
    print("Possible")
else:
    print("Impossible")

Problem: p03657
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b=map(int,input().split())
print('Possible' if a%3==0 or b%3==0 or a+b%3==0 else 'Impossible')

Failing test case input:
-13 4

Expected output:
Possible


Actual output:
Impossible


Fixed submission (verdict: Accepted):
a,b=map(int,input().split())
print('Possible' if a%3==0 or b%3==0 or (a+b)%3==0 else 'Impossible')

Problem: p03657
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
import sys




def read_int_list():
    return list(map(int, input().split()))


def read_str_list():
    return input().split()


def read_int():
    return int(input())


def read_str():
    return input()


a, b = read_int_list()
if a + b >= 3:
    print('Possible')
else:
    print('Impossible')


Failing test case input:
0 -17

Expected output:
Possible


Actual output:
Impossible


Fixed submission (verdict: Accepted):
import sys




def read_int_list():
    return list(map(int, input().split()))


def read_str_list():
    return input().split()


def read_int():
    return int(input())


def read_str():
    return input()


a, b = read_int_list()
if (a + b) % 3 == 0 or a % 3 == 0 or b % 3 == 0:
    print('Possible')
else:
    print('Impossible')
Problem: p03657
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
a, b = map(int, input().split())


if (a+b)%3 >= 0:
    print("Possible")
if a%3 >= 0:
    print("Possible")
if b%3 >= 0:
    print("Possible")
else:
    print("Impossible")

Failing test case input:
15 -3

Expected output:
Possible


Actual output:
Possible
Possible
Possible


Fixed submission (verdict: Accepted):
a, b = map(int, input().split())


if (a+b)%3 == 0:
    print("Possible")
elif a%3 == 0:
    print("Possible")
elif b%3 == 0:
    print("Possible")
else:
    print("Impossible")

Problem: p03657
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b = map(int, input().split())

if (a + b) % 3 == 0:
    print("Possible")
else:
    print("Impossible")

Failing test case input:
-4 -18

Expected output:
Possible


Actual output:
Impossible


Fixed submission (verdict: Accepted):
a, b = map(int, input().split())

if (a + b) % 3 == 0 or a % 3 == 0 or b % 3 == 0:
    print("Possible")
else:
    print("Impossible")

Problem: p03657
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A, B = [int(_) for _ in input().split()]

if (A + B) % 3 == 0:
    print("Possible")
else:
    print("Impossible")

Failing test case input:
-5 -18

Expected output:
Possible


Actual output:
Impossible


Fixed submission (verdict: Accepted):
A, B = [int(_) for _ in input().split()]

if A % 3 == 0 or B % 3 == 0 or (A + B) % 3 == 0:
    print("Possible")
else:
    print("Impossible")

Problem: p03657
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b=map(int,input().split())
print('Possible' if a%3==0 or b%3==0 or (a+b)%3==0 else 'Inpossible')

Failing test case input:
5 -4

Expected output:
Impossible


Actual output:
Inpossible


Fixed submission (verdict: Accepted):
a,b=map(int,input().split())
print('Possible' if a%3==0 or b%3==0 or (a+b)%3==0 else 'Impossible')

Problem: p03657
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A,B = map(int, input().split())

if (A % 3 == 0) or\
    (B % 3 == 0) or\
    (A+B % 3 == 0):
        print("Possible")
else:
    print("Impossible")

Failing test case input:
7 -4

Expected output:
Possible


Actual output:
Impossible


Fixed submission (verdict: Accepted):
A,B = map(int, input().split())

if (A % 3 == 0) or\
    (B % 3 == 0) or\
    ((A+B) % 3 == 0):
        print("Possible")
else:
    print("Impossible")

Problem: p03657
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
a, b = map(int, input().split())
print("possible" if a % 3 == 0 or b % 3 == 0 or (a+b)%3 == 0 else "Impossible")

Failing test case input:
15 -3

Expected output:
Possible


Actual output:
possible


Fixed submission (verdict: Accepted):
a, b = map(int, input().split())
print("Possible" if a % 3 == 0 or b % 3 == 0 or (a+b)%3 == 0 else "Impossible")
Problem: p03109
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
s = input()
if int(s[5:6]) <=4:
  print('Heisei')
else:
  print('TBD')

Failing test case input:
2021/11/90

Expected output:
TBD 


Actual output:
Heisei


Fixed submission (verdict: Accepted):
s = input()
if int(s[5:7]) <=4:
  print('Heisei')
else:
  print('TBD')

Problem: p03109
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a = input()
if int(a[6])<=4:
  print('Heisei')
else:
  print('TBD')

Failing test case input:
2092/10/02

Expected output:
TBD 


Actual output:
Heisei


Fixed submission (verdict: Accepted):
a = input()
if int(a[5])==0 and int(a[6])<=4:
  print('Heisei')
else:
  print('TBD')

Problem: p03109
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
S = input()

A = S.split('/')

if int(A[0]) <= 2019 and int(A[1]) <= 4:
    print("heisei")
else:
  print("TBD")
  

Failing test case input:
1019/04/20

Expected output:
Heisei


Actual output:
heisei


Fixed submission (verdict: Accepted):
S = input()

A = S.split('/')

if int(A[0]) == 2019 and int(A[1]) <= 4:
    print("Heisei")
elif int(A[0]) < 2019:
  print("Heisei")
else:
  print("TBD")

Problem: p03109
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
Y, M, D = map(int, input().split('/'))
if M <= 4:
    print('Heisei')
else:
    print('TDB')


Failing test case input:
2209/10/10

Expected output:
TBD 


Actual output:
TDB


Fixed submission (verdict: Accepted):
Y, M, D = map(int, input().split('/'))
if M <= 4:
    print('Heisei')
else:
    print('TBD')

Problem: p03109
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
S = input()
T = ("2019/05/01")
if S[5:7] == T:
  print("TBD")
else:
  print("Heisei")

Failing test case input:
2029/11/00

Expected output:
TBD 


Actual output:
Heisei


Fixed submission (verdict: Accepted):
S = input()
if int(S[5:7]) <= 4:
    print("Heisei")
else:
    print("TBD")

Problem: p03109
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a = input()
m = int(a[5:7])
if(m<4):
    print("Heisei")
else:
    print("TBD")

Failing test case input:
1018/04/20

Expected output:
Heisei


Actual output:
TBD


Fixed submission (verdict: Accepted):
a = input()
m = int(a[5:7])
if(m<=4):
    print("Heisei")
else:
    print("TBD")

Problem: p03109
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
s = input()
li = s.split('/')
date = int(li[0])*10000 + int(li[1])*100 + int(li[2])*100
if date <= 20190430:
    print('Heisei')
else:
    print('TBD')

Failing test case input:
2019/01/10

Expected output:
Heisei


Actual output:
TBD


Fixed submission (verdict: Accepted):
s = input()
li = s.split('/')
date = int(li[0])*10000 + int(li[1])*100 + int(li[2])
if date <= 20190430:
    print('Heisei')
else:
    print('TBD')
Problem: p03109
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
y,m,d =map(int,input().split("/"))
ans = 'heisei'
if y > 2019:
    ans = 'TBD'
elif y == 2019:
    if m >5:
        ans = 'TBD'
print(ans)

Failing test case input:
1409/00/30

Expected output:
Heisei


Actual output:
heisei


Fixed submission (verdict: Accepted):
y,m,d =map(int,input().split("/"))
ans = 'Heisei'
if y > 2019:
    ans = 'TBD'
elif y == 2019:
    if m >4:
        ans = 'TBD'
print(ans)

Problem: p03109
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
S = input().split('/')

if S[0] == '2019' and S[1] > '05':
    print('TBD')
else:
    print('Heisei')

Failing test case input:
2119/24/10

Expected output:
TBD 


Actual output:
Heisei


Fixed submission (verdict: Accepted):
S = input().split('/')

if S[1] >= '05':
    print('TBD')
else:
    print('Heisei')

Problem: p03109
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
input = list(map(str, input().split("/")))

heisei=20190431

input_kai=int(str(input[0])+input[1].zfill(2)+input[2].zfill(2))
print(input_kai)

if heisei>=input_kai:
    print("Heisei")
else:
    print("TBD")


Failing test case input:
9012/22/01

Expected output:
TBD 


Actual output:
90122201
TBD


Fixed submission (verdict: Accepted):
input = list(map(str, input().split("/")))

heisei=20190430
input_kai=int(input[0].zfill(4)+input[1].zfill(2)+input[2].zfill(2))

if input_kai<=heisei:
    print("Heisei")
else:
    print("TBD")

Problem: p03109
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
x=str(input())
if int(x[:4])>2019:
	print("TBD")
elif int(x[:4])==2019 & int(x[5:7])>4:
	print("TBD")
else:
  	print("Heisei")
  

Failing test case input:
2019/11/10

Expected output:
TBD 


Actual output:
Heisei


Fixed submission (verdict: Accepted):
x=str(input())
if int(x[:4])>2019:
	print("TBD")
elif int(x[:4])==2019 and int(x[5:7])>4:
	print("TBD")
else:
  	print("Heisei")

Problem: p03109
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
s = input()
print('Heisei' if s<='2019/4/30' else 'TBD')

Failing test case input:
2019/14/20

Expected output:
TBD 


Actual output:
Heisei


Fixed submission (verdict: Accepted):
s = input()
print('Heisei' if s<='2019/04/30' else 'TBD')

Problem: p03109
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
date = int(input().replace('/', ''))
print('Heisei' if date >= 20190430 else 'TBD')


Failing test case input:
2019/11/00

Expected output:
TBD 


Actual output:
Heisei


Fixed submission (verdict: Accepted):
date = int(input().replace('/', ''))
print('Heisei' if date <= 20190430 else 'TBD')

Problem: p03109
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
s = input()
print("Heisei" if s<"2019/04/30" else "TBD")

Failing test case input:
2019/04/30

Expected output:
Heisei

Actual output:
TBD


Fixed submission (verdict: Accepted):
s = input()
print("Heisei" if s<="2019/04/30" else "TBD")
Problem: p03109
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a=input()

if int(a[6])<=4:
  print("Heisei")
else:
  print("TBD")

Failing test case input:
2019/33/00

Expected output:
TBD 


Actual output:
Heisei


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

if int(a[5]+a[6])<=4:
  print("Heisei")
else:
  print("TBD")

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


a = list(map(int,input().split("/")))   

if a[0]==2019 and a[1]>=4:
  print("TBD")
elif a[0]>2019:
  print("TBD")
else:
  print("Heisei")

Failing test case input:
2019/04/20

Expected output:
Heisei


Actual output:
TBD


Fixed submission (verdict: Accepted):


a = list(map(int,input().split("/")))   

if a[0]==2019 and a[1]>4:
  print("TBD")
elif a[0]>2019:
  print("TBD")
else:
  print("Heisei")

Problem: p03109
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
s = input().split('/')
ss = list(map(int, s))
if (ss[0] > 2019 and ss[1] >= 5):
  print('TBD')
else:
  print('Heisei')

Failing test case input:
2019/13/30

Expected output:
TBD 


Actual output:
Heisei


Fixed submission (verdict: Accepted):
s = input().split('/')
ss = list(map(int, s))
if (ss[0] >= 2019 and ss[1] >= 5):
  print('TBD')
else:
  print('Heisei')

Problem: p03109
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
print('Heisei' if input() <= '2019/04/30' else 'TBF')

Failing test case input:
2019/21/11

Expected output:
TBD 


Actual output:
TBF


Fixed submission (verdict: Accepted):
print('Heisei' if input() <= '2019/04/30' else 'TBD')

Problem: p03109
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
y, m, d = map(int, input().split("/"))

result = "TBD"
if y < 2019:
  result = "heisei"
elif m < 5:
  result = "heisei"

print(result)

Failing test case input:
1008/04/20

Expected output:
Heisei


Actual output:
heisei


Fixed submission (verdict: Accepted):
y, m, d = map(int, input().split("/"))

result = "TBD"
if y < 2019:
  result = "Heisei"
elif m < 5:
  result = "Heisei"

print(result)

Problem: p03109
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,c=map(int,input().split("/"))
if b>=5:
  print("TBD")
else:
  print("heisei")

Failing test case input:
1519/00/03

Expected output:
Heisei


Actual output:
heisei


Fixed submission (verdict: Accepted):
a,b,c=map(int,input().split("/"))
if b>=5:
  print("TBD")
else:
  print("Heisei")

Problem: p03109
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
S = input()
y, m, d = map(int, S.split("/"))
ans = "Heisei"
if y > 2019:
    ans = "TBD"
elif y == 2019:
    if m > 5:
        ans = "TBD"
    elif m == 4 and d == 30:
        ans = "TBD"
print(ans)


Failing test case input:
2019/04/30

Expected output:
Heisei

Actual output:
TBD


Fixed submission (verdict: Accepted):
S = input()
y, m, d = map(int, S.split("/"))
ans = "Heisei"
if y > 2019:
    ans = "TBD"
elif y == 2019:
    if m > 4:
        ans = "TBD"
print(ans)
Problem: p03109
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
x=str(input())
print(x[:4])
print(x[5:7])
if int(x[:4])>2019:
  print("Heisei")
elif int(x[:4])>=2019& int(x[5:7])>4:
  print("TBD")
  

Failing test case input:
1019/04/20

Expected output:
Heisei


Actual output:
1019
04


Fixed submission (verdict: Accepted):
x=str(input())
if int(x[:4])>2019:
	print("TBD")
elif int(x[:4])==2019 and int(x[5:7])>4:
	print("TBD")
else:
  	print("Heisei")

Problem: p03109
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
s = input()
if int(s[5:7])>4:
  print("TBD")
else:
  print("heisei")

Failing test case input:
2019/04/30

Expected output:
Heisei

Actual output:
heisei


Fixed submission (verdict: Accepted):
s = input()
if int(s[5:7])>4:
  print("TBD")
else:
  print("Heisei")

Problem: p03109
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
s = str(input())

nexts = s.replace("/","")

sint = int(nexts)

print(sint)


if sint <= 20190430:
    print("Heisei")
else:
    print("TBD")
    


Failing test case input:
2019/43/00

Expected output:
TBD 


Actual output:
20194300
TBD


Fixed submission (verdict: Accepted):
s = str(input())

nexts = s.replace("/","")

sint = int(nexts)

if sint <= 20190430:
    print("Heisei")
else:
    print("TBD")

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


y,m,d = map(int, input().split('/'))


if y < 2019:
    print('Heisei')
elif y >= 2019 and m <= 4:
    print('Heisei')
else:
    print('TED')

Failing test case input:
2207/20/11

Expected output:
TBD 


Actual output:
TED


Fixed submission (verdict: Accepted):


y,m,d = map(int, input().split('/'))


if y < 2019:
    print('Heisei')
elif y == 2019 and m <= 4:
    print('Heisei')
else:
    print('TBD')

Problem: p03109
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
S=input().split("/")
if int(S[0])>=2019 and int(S[1])>=5:
    print("TBD")
else:
    print("heisei")

Failing test case input:
2019/04/30

Expected output:
Heisei

Actual output:
heisei


Fixed submission (verdict: Accepted):
S=input().split("/")
if int(S[0])>=2019 and int(S[1])>=5:
  print("TBD")
else:
  print("Heisei")

Problem: p03109
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
s=input()

if s<="2019/04/30":
  print("HEISEI")
else:
  print("TBD")

Failing test case input:
1409/00/30

Expected output:
Heisei


Actual output:
HEISEI


Fixed submission (verdict: Accepted):
s=input()

if s<="2019/04/30":
  print("Heisei")
else:
  print("TBD")

Problem: p03109
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
s = input()
if int(s[:4]) > 2019:
  print("Heisei")
elif int(s[5:7]) >= 5:
  print("Heisei")
else:
  print("TBD")

Failing test case input:
2013/04/90

Expected output:
Heisei


Actual output:
TBD


Fixed submission (verdict: Accepted):
s = input()
if int(s[:4]) > 2019:
  print("TBD")
elif int(s[5:7]) >= 5:
  print("TBD")
else:
  print("Heisei")
Problem: p03109
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
s = input()
if int(s[:4])<2019 and int(s[5:7])<4:
    print("Heisei")
else:
    print("TBD")


Failing test case input:
2019/02/20

Expected output:
Heisei


Actual output:
TBD


Fixed submission (verdict: Accepted):
s = input()
if int(s[:4])<=2019 and int(s[5:7])<=4:
    print("Heisei")
else:
    print("TBD")

Problem: p03109
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
s = input()
print("Heisei" if  s <= "2019/4/30" else "TBD" )

Failing test case input:
2019/13/30

Expected output:
TBD 


Actual output:
Heisei


Fixed submission (verdict: Accepted):
s = input()
print("Heisei" if  s <= "2019/04/30" else "TBD" )

Problem: p03109
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
s = input()
if int(s[5:7]) < 4:
    print ("Heisei")
else :
    print ('TBD')


Failing test case input:
2019/04/30

Expected output:
Heisei

Actual output:
TBD


Fixed submission (verdict: Accepted):
s = input()
if int(s[5:7]) <= 4 :
    print ("Heisei")
else :
      print ('TBD')

Problem: p03109
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
moji = str(input())
if int(moji[0:4]) < 2019:
  print("Heisei")
elif int(moji[0:4]) == 2019:
  if int(moji[6:7])<=4:
    print("Heisei")
  else:
    print("TBD")
else:
  print("TBD")

Failing test case input:
2019/11/11

Expected output:
TBD 


Actual output:
Heisei


Fixed submission (verdict: Accepted):
moji = str(input())
if int(moji[0:4]) < 2019:
  print("Heisei")
elif int(moji[0:4]) == 2019:
  if int(moji[5:6]) == 0 and int(moji[6:7])<=4:
    print("Heisei")
  else:
    print("TBD")
else:
  print("TBD")

Problem: p03109
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
s=str(input())
t='2019/04/30'
if t<s:
    print('TBD')
else:
    print('heisei')


Failing test case input:
0408/00/31

Expected output:
Heisei


Actual output:
heisei


Fixed submission (verdict: Accepted):
s=str(input())
t='2019/04/30'
if t<s:
    print('TBD')
else:
    print('Heisei')

Problem: p03109
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
S=input();print('TBD'if int(S[5])*4+int(S[6])>=4else'Heisei')

Failing test case input:
1008/04/20

Expected output:
Heisei


Actual output:
TBD


Fixed submission (verdict: Accepted):
S=input();print('TBD'if int(S[5])*5+int(S[6])>=5else'Heisei')

Problem: p03109
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
S=input().split('/')
if S[1] == '4':
	print('Heisei')
else:
	print('TBD')

Failing test case input:
2019/01/10

Expected output:
Heisei


Actual output:
TBD


Fixed submission (verdict: Accepted):
S=input().split('/')
S=[int(i) for i in S]
if S[1] <= 4:
	print('Heisei')
else:
	print('TBD')

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


a = list(map(int,input().split("/")))   

if a[0]==2019 and a[1]>=4:
  print("TBD")
elif a[0]<2019:
  print("TBD")
else:
  print("Heisei")

Failing test case input:
0408/00/31

Expected output:
Heisei


Actual output:
TBD


Fixed submission (verdict: Accepted):


a = list(map(int,input().split("/")))   

if a[0]==2019 and a[1]>4:
  print("TBD")
elif a[0]>2019:
  print("TBD")
else:
  print("Heisei")
Problem: p03109
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
s = input().split("/")

if int(s[0]) == 2019:
    if int(s[1]) == 4:
        if int(s[2]) <=30:
            print("Heisei")  
        else:
            print("TDB")        
    if int(s[1]) > 4:
        print("TDB")     
    if int(s[1]) < 4:   
        print("Heisei")  
        
elif int(s[0]) > 2019:
    print("TDB")     

elif int(s[0]) < 2019:
    print("Heisei")  


Failing test case input:
2219/20/11

Expected output:
TBD 


Actual output:
TDB


Fixed submission (verdict: Accepted):
s = list((map(int, input().split("/"))))

if s[0] == 2019:
    if s[1] == 4:
        if s[2] <=30:
            print("Heisei")  
        else:
            print("TBD")        
    if s[1] > 4:
        print("TBD")     
    if s[1] < 4:   
        print("Heisei")  
        
elif s[0]> 2019:
    print("TBD")     

elif s[0] < 2019:
    print("Heisei")

Problem: p03109
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
L = list(map(int, input().split("/")))
print("Heisesi" if L[1] >= 5 else "TBD")

Failing test case input:
2029/10/12

Expected output:
TBD 


Actual output:
Heisesi


Fixed submission (verdict: Accepted):
L = list(map(int, input().split("/")))
print("TBD" if L[1] >= 5 else "Heisei")

Problem: p03109
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
y, m, d = map(int, input().split("/"))
print(y, m, d)
if y > 2019:
    print("TBD")
elif y == 2019:
    if m > 5:
        print("TBD")
    else:
        print("Heisei")
else:
    print("Heisei")


Failing test case input:
2111/20/91

Expected output:
TBD 


Actual output:
2111 20 91
TBD


Fixed submission (verdict: Accepted):
y, m, d = map(int, input().split("/"))
if y > 2019:
    print("TBD")
elif y == 2019:
    if m > 4:
        print("TBD")
    else:
        print("Heisei")
else:
    print("Heisei")

Problem: p03109
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
S = input()
if S[5] == 0 and int(S[6]) <= int('5'):
    print('Heisei')
else:
    print('TBD')

Failing test case input:
1419/00/03

Expected output:
Heisei


Actual output:
TBD


Fixed submission (verdict: Accepted):
S = input()
if S[5] == '0' and int(S[6]) < int('5'):
    print('Heisei')
else:
    print('TBD')

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

y, m, d = map(int, input().split("/"))

if y >= 2019:
    if m <= 4:
        if d >= 30:
            print("Heisei")
else:
    print("TBD")

Failing test case input:
2119/11/20

Expected output:
TBD 


Actual output:

Fixed submission (verdict: Accepted):

y, m, d = map(int, input().split("/"))
heisei = 0
if y <= 2019:
    heisei += 1
    if m <= 4:
        heisei += 1
        if d >= 30:
            heisei += 1
if heisei > 1:
    print("Heisei")
else:
    print("TBD")
Problem: p03109
Buggy submission (Python (3.4.3), verdict: Wrong Answer):



y,m,d = map(int,input().split("/"))

h='Heisei'
t = 'TBD'

if y > 2019:
  print(t)
elif y < 2020:
  print(h)
else:
  if m > 4:
    print(t)
  elif m < 4:
    print(h)
  else:
    if m > 30:
      print(t)
    else:
      print(h)


Failing test case input:
2019/24/10

Expected output:
TBD 


Actual output:
Heisei


Fixed submission (verdict: Accepted):



y,m,d = map(int,input().split("/"))

h='Heisei'
t = 'TBD'

if m > 4:
    print(t)
elif m < 4:
    print(h)
else:
    if m > 30:
        print(t)
    else:
        print(h)

Problem: p03109
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
import sys

y, m, d = map(int, sys.stdin.readline().split("/"))
if (y == 2019 and m <= 4) or y < 2019:
    print('heisei')
else:
    print('TBD')


Failing test case input:
2019/04/20

Expected output:
Heisei


Actual output:
heisei


Fixed submission (verdict: Accepted):
import sys

y, m, d = map(int, sys.stdin.readline().split("/"))
if (y == 2019 and m <= 4) or y < 2019:
    print('Heisei')
else:
    print('TBD')

Problem: p03109
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
y,m,d=map(int,input().split("/"))
if y<2019:
    print("Heisei")
elif y==2019:
    if m<=4:
        print("Heisei")
else:
    print("TBD")

Failing test case input:
2019/14/20

Expected output:
TBD 


Actual output:

Fixed submission (verdict: Accepted):
y,m,d=map(int,input().split("/"))
if y<2019:
    print("Heisei")
elif y==2019 and m<=4:
        print("Heisei")
else:
    print("TBD")

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

y, m, d = map(int, input().split("/"))

if y <= 2019:
    if m <= 4:
        if d >= 30:
            print("Heisei")
else:
    print("TBD")

Failing test case input:
2019/04/20

Expected output:
Heisei


Actual output:

Fixed submission (verdict: Accepted):

y, m, d = map(int, input().split("/"))
heisei = 0
if y <= 2019:
    heisei += 1
    if m <= 4:
        heisei += 1
        if d >= 30:
            heisei += 1
if heisei > 1:
    print("Heisei")
else:
    print("TBD")

Problem: p03109
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
y, m, d = map(int, str(input()).split("/"))

if y < 2019:
    print("Heisei")
elif m < 5:
    print("Heisei")
elif d < 31:
    print("Heisei")
else:
    print("TBD")

Failing test case input:
2092/10/02

Expected output:
TBD 


Actual output:
Heisei


Fixed submission (verdict: Accepted):
import sys

y, m, d = map(int, str(input()).split("/"))

if y < 2019:
    print("Heisei")
    sys.exit()
elif m < 5:
    print("Heisei")
    sys.exit()

else:
    print("TBD")

Problem: p03109
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):

S = list(map(int, input().split('/')))

if S[0] == 2019 and S[1] == 4 and S[2] <= 30:
    print('Heisei')
else:
    print('TBD')

Failing test case input:
1409/00/30

Expected output:
Heisei


Actual output:
TBD


Fixed submission (verdict: Accepted):

S = list(map(int, input().split('/')))

if S[0] <= 2018 or S[0] == 2019 and S[1] <= 4 and S[2] <= 30:
    print('Heisei')
else:
    print('TBD')
Problem: p03109
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
s = input()
if s == '2019/04/30':
    print('Heisei')
else:
    print('TBD')

Failing test case input:
2019/03/20

Expected output:
Heisei


Actual output:
TBD


Fixed submission (verdict: Accepted):
s = input().replace('/','')
if int(s) <= 20190430:
    print('Heisei')
else:
    print('TBD')

Problem: p03109
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
y, m, d = list(input().split('/'))

n = int(y + m + d)

if n <= 20190430:
  print("Heisei")
else:
  print("TDB")



Failing test case input:
2019/21/01

Expected output:
TBD 


Actual output:
TDB


Fixed submission (verdict: Accepted):
y, m, d = list(input().split('/'))


n = int(y + m + d)

if n <= 20190430:
  print("Heisei")
else:
  print("TBD")

Problem: p03109
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
S=input()
Stmp=S.split('/')

YY=int(Stmp[0])
MM=int(Stmp[1])
DD=int(Stmp[2])

if YY<2019:
    print('TBD')
else:
    if MM<4:
        print('TBD')
    else:
        if DD<30:
            print('TBD')
        else:
            print('Heisei')
            

Failing test case input:
1419/00/03

Expected output:
Heisei


Actual output:
TBD


Fixed submission (verdict: Accepted):



S=input()

Stmp=S.split('/')

YY=int(Stmp[0])
MM=int(Stmp[1])
DD=int(Stmp[2])

if YY<2019:
    print('Heisei')
else:
    if MM<5:
        print('Heisei')
    else:
        print('TBD')

Problem: p03109
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
S = str(input())

y = ''
m = ''
d = ''
num = 0
tmp = ''
for s in list(S):
  if s == '/':
    if num == 0:
      y = tmp
    elif num == 1:
      m = tmp
    else:
      d = tmp
    tmp = ''
  else:
    tmp += s

if int(y + m + d) > 20190430:
  print("TBD")
else:
  print("Heisei")

Failing test case input:
2119/12/11

Expected output:
TBD 


Actual output:
Heisei


Fixed submission (verdict: Accepted):
S = str(input())

y = ''
m = ''
d = ''
num = 0
tmp = ''
for index, s in enumerate(list(S)):
  if s == '/':
    if num == 0:
      y = tmp
    elif num == 1:
      m = tmp
    tmp = ''
    num += 1
  else:
    tmp += s
  if index == len(list(S)) - 1:
    d = tmp

if int(y + m + d) > 20190430:
  print("TBD")
else:
  print("Heisei")

Problem: p03109
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
s = input()
if s[5::] == "04/30":
  print("Heisei")
else:
  print("TBD")

Failing test case input:
2013/04/90

Expected output:
Heisei


Actual output:
TBD


Fixed submission (verdict: Accepted):
s = input()
if int(s[6]) <= 4 and int(s[5]) == 0:
  print("Heisei")
else:
  print("TBD")

Problem: p03109
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a=input().split('/')
a=a[0]+a[1]+a[2]
if int(a) > 20190430:
  print("TDB")
else:
  print('Heisei')

Failing test case input:
3111/12/91

Expected output:
TBD 


Actual output:
TDB


Fixed submission (verdict: Accepted):
a=input().split('/')
a=a[0]+a[1]+a[2]
if int(a) > 20190430:
  print("TBD")
else:
  print('Heisei')
Problem: p03109
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
S = input().split("/")
print("Heisei" if int(S[1]) >= 5 else "TBD")

Failing test case input:
2019/03/20

Expected output:
Heisei


Actual output:
TBD


Fixed submission (verdict: Accepted):

S = input().split("/")
print("Heisei" if int(S[1]) < 5 else "TBD")

Problem: p03109
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
S = input()
y, m, d = map(int, S.split("/"))
ans = "TBD"
if y < 2019:
    ans = "Heisei"
if m < 4:
    ans = "Heisei"
elif y == 2019 and m == 4 and d == 30:
    ans = "Heisei"
print(ans)

Failing test case input:
2019/04/20

Expected output:
Heisei


Actual output:
TBD


Fixed submission (verdict: Accepted):
S = input()
y, m, d = map(int, S.split("/"))
ans = "TBD"
if y < 2019:
    ans = "Heisei"
elif y == 2019 and m <= 4:
    ans = "Heisei"
print(ans)

Problem: p03109
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a='2020/03/30'
d=a.split(sep='/')
if(int(d[0])<2019):
        print("Heisei")
elif(int(d[0])==2019 and int(d[1])<4):
        print("Heisei")
elif(int(d[0])==2019 and int(d[1])==4 and int(d[2])<=30):
        print("Heisei")
else:
        print("TBD")

Failing test case input:
2019/01/00

Expected output:
Heisei


Actual output:
TBD


Fixed submission (verdict: Accepted):
a=str(input())
d=a.split(sep='/')
if(int(d[0])<2019):
        print("Heisei")
elif(int(d[0])==2019 and int(d[1])<4):
        print("Heisei")
elif(int(d[0])==2019 and int(d[1])==4 and int(d[2])<=30):
        print("Heisei")
else:
        print("TBD")

Problem: p03109
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
y, m, d = map(int,input().split('/'))
if y*1000 + m*100 + d <= 20190430 :
  print('Heisei')
else:
  print('TBD')

Failing test case input:
2119/12/11

Expected output:
TBD 


Actual output:
Heisei


Fixed submission (verdict: Accepted):
y, m, d = map(int,input().split('/'))
if y*10000 + m*100 + d <= 20190430 :
  print('Heisei')
else:
  print('TBD')

Problem: p03109
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
S = list(input().split('/'))
A = S[0]+S[1]+S[2]
print(A)
if int(A) > 20190430:
  print("TBD")
else:
  print("Heisei")

Failing test case input:
3111/12/91

Expected output:
TBD 


Actual output:
31111291
TBD


Fixed submission (verdict: Accepted):
S = list(input().split('/'))
A = S[0]+S[1]+S[2]

if int(A) > 20190430:
  print("TBD")
else:
  print("Heisei")

Problem: p03109
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
S=input()
if S<='2019/4/30':
  print('Heisei')
else:
  print('TBD')


Failing test case input:
2019/21/01

Expected output:
TBD 


Actual output:
Heisei


Fixed submission (verdict: Accepted):
S=input()
if S<='2019/04/30':
  print('Heisei')
else:
  print('TBD')
Problem: p03109
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a = input().split('/')
if int(a[0]) > 2019 and int(a[1]) > 5:
  print('TBD')
  
else:
  print('Heisei')


Failing test case input:
2019/11/10

Expected output:
TBD 


Actual output:
Heisei


Fixed submission (verdict: Accepted):
a = input().split('/')
if a[1][0] == '0':
  a[1] = a[1][1]
if int(a[0]) >= 2019 and int(a[1]) >= 5:
  print('TBD')
  
else:
  print('Heisei')

Problem: p03109
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
s = input()
print('Heisei' if "2019/04/30" >= s else 'TED')

Failing test case input:
3111/12/81

Expected output:
TBD 


Actual output:
TED


Fixed submission (verdict: Accepted):
s = input()
print('Heisei' if "2019/04/30" >= s else 'TBD')

Problem: p03109
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
import sys

y, m, d = map(int, str(input()).split("/"))

if y < 2019:
    print("Heisei")
    sys.exit()
elif m < 5:
    print("Heisei")
    sys.exit()
elif d < 31:
    print("Heisei")
    sys.exit()
else:
    print("TBD")


Failing test case input:
2209/20/21

Expected output:
TBD 


Actual output:
Heisei


Fixed submission (verdict: Accepted):
import sys

y, m, d = map(int, str(input()).split("/"))

if y < 2019:
    print("Heisei")
    sys.exit()
elif m < 5:
    print("Heisei")
    sys.exit()

else:
    print("TBD")

Problem: p03109
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
s=input()
if s>"2019/4/30":
  print("TBD")
else:
  print("Heisei")

Failing test case input:
2019/13/30

Expected output:
TBD 


Actual output:
Heisei


Fixed submission (verdict: Accepted):
s=input()
if s>"2019/04/30":
  print("TBD")
else:
  print("Heisei")

Problem: p03109
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
S = input()
y, m, d = map(int, S.split("/"))
ans = "TBD"
if y < 2019:
    ans = "Heisei"
elif m < 4:
    ans = "Heisei"
elif m == 4 and d == 30:
    ans = "Heisei"
print(ans)

Failing test case input:
2019/04/20

Expected output:
Heisei


Actual output:
TBD


Fixed submission (verdict: Accepted):
S = input()
y, m, d = map(int, S.split("/"))
ans = "TBD"
if y < 2019:
    ans = "Heisei"
elif y == 2019 and m <= 4:
    ans = "Heisei"
print(ans)

Problem: p03109
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
s=input()
s_list=s.split('/') 
s1=list(map(int,s_list))
st=[2019,4,30]
if s1[0]<st[0]:
    print('Heisei')
elif s1[0]==st[0] and s1[1]==st[1]:
    print('Heisei')
else:
    print('TBD')

Failing test case input:
2019/03/30

Expected output:
Heisei


Actual output:
TBD


Fixed submission (verdict: Accepted):
s=input()
s_list=s.split('/') 
s1=list(map(int,s_list))
st=[2019,4,30]
if s1[0]<st[0]:
    print('Heisei')
elif s1[0]==st[0] and s1[1]<=st[1]:
    print('Heisei')
else:
    print('TBD')