You have probably registered on Internet sites many times. And each time you should enter your invented password. Usually the registration form automatically checks the password's crypt resistance. If the user's password isn't complex enough, a message is displayed. Today your task is to implement such an automatic check.

Web-developers of the company Q assume that a password is complex enough, if it meets all of the following conditions:  the password length is at least 5 characters;  the password contains at least one large English letter;  the password contains at least one small English letter;  the password contains at least one digit. 

You are given a password. Please implement the automatic check of its complexity for company Q.


-----Input-----

The first line contains a non-empty sequence of characters (at most 100 characters). Each character is either a large English letter, or a small English letter, or a digit, or one of characters: "!", "?", ".", ",", "_".


-----Output-----

If the password is complex enough, print message "Correct" (without the quotes), otherwise print message "Too weak" (without the quotes).


-----Examples-----
Input
abacaba

Output
Too weak

Input
X12345

Output
Too weak

Input
CONTEST_is_STARTED!!11

Output
Correct

Difficulty: EASY

Solutions:
from re import findall
if (lambda s: len(s) > 4 and findall('[A-Z]', s) and findall('[a-z]', s) and findall('[0-9]', s))(input().strip()):
	print('Correct')
else:
	print('Too weak')


S = input()
ans = 0
Ans = 0
ns = 0
for i in range(len(S)):
	k = ord(S[i])
	if k >= 48 and k <= 57:
		ns += 1
	elif k >= 65 and k <= 90:
		Ans += 1
	elif k >= 97 and k <= 122:
		ans += 1
if ans != 0 and Ans != 0 and (len(S) >= 5) and (ns != 0):
	print('Correct')
else:
	print('Too weak')


s = input().strip()
if len(s) < 5:
	print('Too weak')
	exit()
cl = 0
sl = 0
d = 0
for c in s:
	oc = ord(c)
	if oc >= 65 and oc <= 90:
		cl = 1
	if oc >= 97 and oc <= 122:
		sl = 1
	if oc >= 48 and oc <= 57:
		d = 1
	if d == 1 and sl == 1 and (cl == 1):
		print('Correct')
		exit()
print('Too weak')


s = input()
(u, l, d) = map(lambda x: sum(map(x, s)), [str.isupper, str.islower, str.isdigit])
print(['Too weak', 'Correct'][(len(s) >= 5) * u * l * d != 0])


s = input()
(a, b, c) = (0, 0, 0)
for i in s:
	if 47 < ord(i) < 58:
		a += 1
		break
for j in s:
	if 64 < ord(j) < 91:
		b += 1
		break
for k in s:
	if 96 < ord(k) < 123:
		c += 1
		break
if len(s) > 4:
	if a != 0 and b != 0 and (c != 0):
		print('Correct')
	else:
		print('Too weak')
else:
	print('Too weak')


import re
line = input()
print(['Too weak', 'Correct'][len(line) > 4 and re.search('[0-9]', line) != None and (re.search('[a-z]', line) != None) and (re.search('[A-Z]', line) != None)])


n = input()
L2 = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '0']
(count1, count3, count4) = (0, 0, 0)
for i in n:
	if i.isupper():
		count1 += 1
	elif i.islower():
		count4 += 1
	for k in L2:
		if k == i:
			count3 += 1
if len(n) >= 5 and (count1 and count3 and count4) >= 1:
	print('Correct')
else:
	print('Too weak')


s = input().strip()
flag1 = len(s) >= 5
d1 = 'qwertyuiopasdfghjklzxcvbnm'
d2 = 'QWERTYUIOPASDFGHJKLZXCVBNM'
d3 = '1234567890'
flag2 = False
flag3 = False
flag4 = False
for i in d1:
	if i in s:
		flag2 = True
for i in d2:
	if i in s:
		flag3 = True
for i in d3:
	if i in s:
		flag4 = True
if flag1 and flag2 and flag3 and flag4:
	print('Correct')
else:
	print('Too weak')


import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
from collections import Counter
x = input()
ans = 'Correct'
if len(x) < 5:
	ans = 'Too weak'
if not (any((i.isupper() for i in x)) and any((i.islower() for i in x)) and any((i.isdigit() for i in x))):
	ans = 'Too weak'
print(ans)


password = input()
haslower = False
hasupper = False
hasdigit = False
hasspecial = False
if len(password) >= 5:
	for i in password:
		if 'a' <= i <= 'z':
			haslower = True
		if 'A' <= i <= 'Z':
			hasupper = True
		if '0' <= i <= '9':
			hasdigit = True
if haslower and hasupper and hasdigit:
	print('Correct')
else:
	print('Too weak')


s = input()
(x, y, z) = (0, 0, 0)
n = len(s)
if n < 5:
	print('Too weak')
else:
	for i in s:
		if i.isupper():
			x = 1
			break
	for i in s:
		if i.islower():
			y = 1
			break
	for i in s:
		if i.isdigit():
			z = 1
			break
	if x == 1 and y == 1 and (z == 1):
		print('Correct')
	else:
		print('Too weak')


import string

def selection_sort(l):
	for i in range(len(l)):
		min_val = l[i]
		min_val_index = i
		for j in range(i, len(l)):
			if l[j] < min_val:
				min_val = l[j]
				min_val_index = j
		(l[i], l[min_val_index]) = (l[min_val_index], l[i])
	return l

def merge_sort(l):

	def merge(l1, l2):
		output_list = []
		(i, j) = (0, 0)
		while i < len(l1) and j < len(l2):
			if l1[i] < l2[j]:
				output_list.append(l1[i])
				i += 1
			else:
				output_list.append(l2[j])
				j += 1
		if i == len(l1):
			output_list += l2[j:]
		else:
			output_list += l1[i:]
		return output_list

	def sort(li):
		if len(li) < 2:
			return li
		mid = len(li) // 2
		left = sort(li[:mid])
		right = sort(li[mid:])
		return merge(left, right)
	return sort(l)

def main_function():
	is_len_greater_than_5 = False
	does_contain_digit = False
	does_contain_upper = False
	does_contain_lower = False
	password = input()
	if len(password) >= 5:
		is_len_greater_than_5 = True
	for i in password:
		if i.isdigit():
			does_contain_digit = True
		elif i.isupper():
			does_contain_upper = True
		elif i.islower():
			does_contain_lower = True
	if is_len_greater_than_5 and does_contain_lower and does_contain_upper and does_contain_digit:
		return 'Correct'
	return 'Too weak'
print(main_function())


import re

def getAnswer(x):
	if len(x) < 5:
		return 'Too weak'
	if re.search('[A-Z]', x) == None:
		return 'Too weak'
	if re.search('[a-z]', x) == None:
		return 'Too weak'
	if re.search('[0-9]', x) == None:
		return 'Too weak'
	return 'Correct'

def main():
	x = input()
	print(getAnswer(x))
main()


import re
s = input()
print(['Too weak', 'Correct'][all([len(s) >= 5, re.search('[a-z]', s), re.search('[A-Z]', s), re.search('\\d', s)])])


x = input()
x = list(x)
p = 0
if len(x) > 4:
	for i in x:
		if i.isnumeric():
			p += 1
			break
	for i in x:
		if i.isupper():
			p += 1
			break
	for i in x:
		if i.islower():
			p += 1
			break
if p == 3:
	print('Correct')
else:
	print('Too weak')


import fileinput

def test():
	pass
pw = input()
criteria = 0
if len(pw) >= 5:
	criteria += 1
	for let in pw:
		if ord(let) in range(65, 91):
			criteria += 1
			break
	for let in pw:
		if ord(let) in range(97, 123):
			criteria += 1
			break
	for let in pw:
		if ord(let) in range(48, 58):
			criteria += 1
			break
	if criteria == 4:
		print('Correct')
	else:
		print('Too weak')
else:
	print('Too weak')


T_ON = 0
DEBUG_ON = 0
MOD = 998244353

def solve():
	s = input()
	check_len = check_upper = check_lower = check_digit = False
	check_len = len(s) >= 5
	for c in s:
		if c.islower():
			check_lower = True
		elif c.isupper():
			check_upper = True
		elif c.isdigit():
			check_digit = True
	if check_len and check_upper and check_lower and check_digit:
		print('Correct')
	else:
		print('Too weak')

def main():
	T = read_int() if T_ON else 1
	for i in range(T):
		solve()

def debug(*xargs):
	if DEBUG_ON:
		print(*xargs)
from collections import *
import math
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

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

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

def print_nums(nums):
	print(' '.join(map(str, nums)))

def YES():
	print('YES')

def Yes():
	print('Yes')

def NO():
	print('NO')

def No():
	print('No')

def First():
	print('First')

def Second():
	print('Second')

def fib(n):
	(a, b) = (0, 1)
	for _ in range(n):
		(a, b) = (b, a + b)
	return a

def fib_ns(n):
	assert n >= 1
	f = [0 for _ in range(n + 1)]
	f[0] = 0
	f[1] = 1
	for i in range(2, n + 1):
		f[i] = f[i - 1] + f[i - 2]
	return f

def gcd(a, b):
	if a == 0:
		return b
	return gcd(b % a, a)

def xgcd(a, b):
	(x0, x1, y0, y1) = (0, 1, 1, 0)
	while a != 0:
		((q, a), b) = (divmod(b, a), a)
		(y0, y1) = (y1, y0 - q * y1)
		(x0, x1) = (x1, x0 - q * x1)
	return (b, x0, y0)

def lcm(a, b):
	d = gcd(a, b)
	return a * b // d

def is_even(x):
	return x % 2 == 0

def is_odd(x):
	return x % 2 == 1

def modinv(a, m):
	(g, x, _) = xgcd(a, m)
	if g != 1:
		raise Exception('gcd(a, m) != 1')
	return x % m

def mod_add(x, y):
	x += y
	while x >= MOD:
		x -= MOD
	while x < 0:
		x += MOD
	return x

def mod_mul(x, y):
	return x * y % MOD

def mod_pow(x, y):
	if y == 0:
		return 1
	if y % 2:
		return mod_mul(x, mod_pow(x, y - 1))
	p = mod_pow(x, y // 2)
	return mod_mul(p, p)

def mod_inv(y):
	return mod_pow(y, MOD - 2)

def mod_div(x, y):
	return mod_mul(x, mod_inv(y))

def is_prime(n):
	if n == 1:
		return False
	for i in range(2, int(n ** 0.5) + 1):
		if n % i:
			return False
	return True

def gen_primes(n):
	P = [True for _ in range(n + 1)]
	P[0] = P[1] = False
	for i in range(int(n ** 0.5) + 1):
		if P[i]:
			for j in range(2 * i, n + 1, i):
				P[j] = False
	return P
main()


a = input()
b = [False] * 3
for k in a:
	if '0' <= k <= '9':
		b[0] = True
	if 'A' <= k <= 'Z':
		b[1] = True
	if 'a' <= k <= 'z':
		b[2] = True
if len(a) >= 5 and b[0] and b[1] and b[2]:
	print('Correct')
else:
	print('Too weak')


import re
s = ''.join(sorted(input()))
print(['Too weak', 'Correct'][bool(re.search('(?=.{5})(?=[0-9]+[?]*[A-Z]+[\\!\\.\\,\\_]*[a-z]+)', s))])


a = input()
t = 0
if len(a) >= 5:
	t += 1
for i in range(len(a)):
	if ord(a[i]) >= ord('A') and ord(a[i]) <= ord('Z'):
		t += 1
		break
for i in range(len(a)):
	if ord(a[i]) >= ord('a') and ord(a[i]) <= ord('z'):
		t += 1
		break
b = '0123456789'
f = 0
for i in range(len(a)):
	if f == 0:
		for j in range(10):
			if a[i] == b[j]:
				t = t + 1
				f = 1
if t == 4:
	print('Correct')
else:
	print('Too weak')


a = input().strip()
flag1 = 0
flag2 = 0
flag3 = 0
for i in range(26):
	if chr(i + ord('a')) in a:
		flag1 = 1
	if chr(i + ord('A')) in a:
		flag2 = 1
	if str(i % 10) in a:
		flag3 = 1
if len(a) >= 5 and flag1 * flag2 * flag3 == 1:
	print('Correct')
else:
	print('Too weak')


s = input()
l = len(s)
x = 0
y = 0
z = 0
m = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
for i in s:
	if i in m:
		x = 1
	elif ord(i) in range(65, 91):
		y = 1
	elif ord(i) in range(97, 123):
		z = 1
if l >= 5 and x == 1 and (y == 1) and (z == 1):
	print('Correct')
else:
	print('Too weak')


s = input().strip()
b = False
l = False
c = False
for i in s:
	if 'a' <= i <= 'z':
		l = True
	if 'A' <= i <= 'Z':
		b = True
	if '0' <= i <= '9':
		c = True
	if b and l and c:
		break
if b and l and c and (len(s) >= 5):
	print('Correct')
else:
	print('Too weak')


s = input()
import string
a = 1
for i in s:
	if i in string.ascii_lowercase:
		a *= 2
	if i in string.ascii_uppercase:
		a *= 3
	if i in string.digits:
		a *= 5
print('Too weak' if a % 30 or len(s) < 5 else 'Correct')


s = input() + '?'
print(['Too weak', 'Correct'][(len(s) >= 6) & (len(set([(i.isupper(), i.islower(), i.isdigit()) for i in s])) == 4)])


S = input()
(lower, upper, number) = (False, False, False)
(L, U, N) = ([str(i) for i in range(10)], [chr(i) for i in range(ord('A'), ord('Z') + 1)], [chr(i) for i in range(ord('a'), ord('z') + 1)])
for letter in S:
	lower = lower or letter in L
	upper = upper or letter in U
	number = number or letter in N
if len(S) >= 5 and lower and upper and number:
	print('Correct')
else:
	print('Too weak')


n = input()
s = 0
if len(n) >= 5:
	for i in n:
		if i >= 'a' and i <= 'z':
			s = s + 1
			break
	if s == 1:
		for j in n:
			if j >= 'A' and j <= 'Z':
				s = s + 1
				break
		if s == 2:
			for k in n:
				if k >= '0' and k <= '9':
					s = s + 1
					break
			if s == 3:
				print('Correct')
			else:
				print('Too weak')
		else:
			print('Too weak')
	else:
		print('Too weak')
else:
	print('Too weak')


def oneSmall(s):
	for i in range(len(s)):
		if s[i].islower():
			return True
	return False

def oneLarge(s):
	for i in range(len(s)):
		if s[i].isupper():
			return True
	return False

def num(s):
	for i in range(len(s)):
		if s[i].isnumeric():
			return True
	return False
s = input()
if len(s) >= 5 and num(s) and oneSmall(s) and oneLarge(s):
	print('Correct')
else:
	print('Too weak')


str = input()
if len(str) < 5:
	print('Too weak\n')
else:
	small = 0
	big = 0
	dig = 0
	for s in str:
		if s.islower():
			small = 1
		if s.isdigit():
			dig = 1
		if s.isupper():
			big = 1
	if small and big and dig:
		print('Correct')
	else:
		print('Too weak')


pw = input()
lg = case = numb = 0
if len(pw) >= 5:
	lg = 1
if pw.lower() != pw and pw.upper() != pw:
	case = 1
for i in pw:
	if i.isnumeric():
		numb = 1
if numb and case and lg:
	print('Correct')
else:
	print('Too weak')


word = input()
d = u = s = False
for i in word:
	if i.isdigit():
		d = True
	if i.isupper():
		u = True
	if i.islower():
		s = True
if d and u and s and (len(word) >= 5):
	print('Correct')
else:
	print('Too weak')


S = input()
a = len(S) >= 5
(b, c, d) = (0, 0, 0)
for i in S:
	if 'A' <= i <= 'Z':
		b = 1
	if 'a' <= i <= 'z':
		c = 1
	if '0' <= i <= '9':
		d = 1
if a + b + c + d == 4:
	print('Correct')
else:
	print('Too weak')


p = input()
(u, l, d) = (0, 0, 0)
for i in p:
	if i.isupper():
		u += 1
	if i.islower():
		l += 1
	if i.isdigit():
		d += 1
if len(p) > 4 and u > 0 and (l > 0) and (d > 0):
	print('Correct')
else:
	print('Too weak')


w = input()
a = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
b = 'abcdefghijklmnopqrstuvwxyz'
c = '0123456789'
l = False
u_c = False
l_c = False
d = False
for i in w:
	if len(w) >= 5:
		l = True
	if i in a:
		u_c = True
	if i in b:
		l_c = True
	if i in c:
		d = True
if l and u_c and l_c and d:
	print('Correct')
else:
	print('Too weak')


import sys
x = input()
count_small = 0
count_big = 0
for i in x:
	if i.islower():
		count_small += 1
for y in x:
	if y.isupper():
		count_big += 1
u = len(x)
if u >= 5:
	if count_big >= 1:
		if count_small >= 1:
			if '1' in x or '2' in x or '3' in x or ('4' in x) or ('5' in x) or ('6' in x) or ('7' in x) or ('8' in x) or ('9' in x) or ('0' in x):
				print('Correct')
				sys.exit()
print('Too weak')


n = input()
a = len(n)
c = 0
c1 = 0
c2 = 0
num = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
if a >= 5:
	for i in range(a):
		if n[i] in num:
			c += 1
		elif n[i] == n[i].upper() and n[i].isalpha():
			c1 += 1
		elif n[i] == n[i].lower() and n[i].isalpha():
			c2 += 1
		if c > 0 and c1 > 0 and (c2 > 0):
			break
	if c > 0 and c1 > 0 and (c2 > 0):
		print('Correct')
	else:
		print('Too weak')
else:
	print('Too weak')


def f(t):
	return len(t) > 4 and any(('0' <= i <= '9' for i in t)) and any(('a' <= i <= 'z' for i in t)) and any(('A' <= i <= 'Z' for i in t))
print('Correct' if f(input()) else 'Too weak')


s = input()
if len(s) < 5:
	print('Too weak')
else:
	c = 0
	for i in s:
		if i.isupper():
			c += 1
			break
	for i in s:
		if i.islower():
			c += 1
			break
	for i in s:
		if i.isnumeric():
			c += 1
			break
	print(['Too weak', 'Correct'][c == 3])


s = input()
small = 0
cap = 0
digit = 0
if len(s) < 5:
	print('Too weak')
else:
	l = list(s)
	for i in range(len(l)):
		if 97 <= ord(l[i]) <= 122:
			small = 1
		if 65 <= ord(l[i]) <= 91:
			cap = 1
		if 48 <= ord(l[i]) <= 57:
			digit = 1
	if small and cap and digit:
		print('Correct')
	else:
		print('Too weak')


import sys
pw = sys.stdin.readline().strip()
if len(pw) >= 5 and any((c.isupper() for c in pw)) and any((c.islower() for c in pw)) and any((c.isdigit() for c in pw)):
	print('Correct')
else:
	print('Too weak')


def check(s):
	x = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
	y = 'abcdefghijklmnopqrstuvwxyz'
	z = '0123456789'
	if len(s) < 5:
		return False
	if len(list(set(list(s)) & set(list(x)))) == 0:
		return False
	if len(list(set(list(s)) & set(list(y)))) == 0:
		return False
	if len(list(set(list(s)) & set(list(z)))) == 0:
		return False
	return True
s = input()
if check(s):
	print('Correct')
else:
	print('Too weak')


password = input()
s_char = 0
c_char = 0
digit = 0
n = len(password)
if n >= 5:
	for i in password:
		if i.islower():
			s_char += 1
		elif i.isupper():
			c_char += 1
		elif i.isdigit():
			digit += 1
	if s_char and c_char and digit:
		print('Correct')
	else:
		print('Too weak')
else:
	print('Too weak')


print('Correct' if (lambda s: len(s) >= 5 and any([c.isdigit() for c in s]) and any([c.islower() for c in s]) and any([c.isupper() for c in s]))(input()) else 'Too weak')


s = input().strip()
c = 0
if len(s) >= 5:
	c += 1
	for i in range(len(s)):
		if ord('a') <= ord(s[i]) <= ord('z'):
			c += 1
			break
	for i in range(len(s)):
		if ord('A') <= ord(s[i]) <= ord('Z'):
			c += 1
			break
	for i in range(len(s)):
		if ord('0') <= ord(s[i]) <= ord('9'):
			c += 1
			break
if c == 4:
	print('Correct')
else:
	print('Too weak')


s = input().strip()
alp = set([chr(i) for i in range(ord('a'), ord('z') + 1)])
upper = set([chr(i) for i in range(ord('A'), ord('Z') + 1)])
num = set([str(i) for i in range(10)])
if len(s) >= 5:
	s = set(list(s))
	if len(s & alp) > 0 and len(s & upper) > 0 and (len(s & num) > 0):
		print('Correct')
	else:
		print('Too weak')
else:
	print('Too weak')


s = str(input())
flag = 0
if len(s) < 5:
	flag = 1
e = 0
f = 0
g = 0
for i in range(0, len(s)):
	if s[i].isdigit():
		g = g + 1
	elif s[i] >= 'a' and s[i] <= 'z':
		e = e + 1
	elif s[i] >= 'A' and s[i] <= 'Z':
		f = f + 1
if e == 0 or f == 0 or g == 0:
	flag = 1
if flag == 1:
	print('Too weak')
else:
	print('Correct')


s = input()
l = []
bolB = 'QWERTYUIOPLKJHGFDSAZXCVBNM'
malB = 'qwertyuioplkjhgfdsazxcvbnm'
cifr = '1234567890'
p1 = 0
p2 = 0
p3 = 0
p4 = 0
for h in s:
	l.append(h)
	if bolB.find(h) >= 0:
		p1 += 1
	if malB.find(h) >= 0:
		p2 += 1
	if cifr.find(h) >= 0:
		p3 += 1
if len(l) >= 5:
	p4 += 1
if p1 >= 1 and p2 >= 1 and (p3 >= 1) and (p4 >= 1):
	print('Correct')
else:
	print('Too weak')


x = input()
a = 0
c = 0
s = 0
if len(x) < 5:
	print('Too weak')
else:
	for i in x:
		if i.isnumeric():
			a = 1
		if i.isupper():
			c = 1
		if i.islower():
			s = 1
	if a == 1 and c == 1 and (s == 1):
		print('Correct')
	else:
		print('Too weak')


upreg = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z']
downreg = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
cifra = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '0']
slovo = input()
flag = [0, 0, 0, 0]
if len(slovo) >= 5:
	flag[0] = 1
for i in range(len(slovo)):
	simvol = slovo[i:i + 1]
	if simvol in upreg:
		flag[1] = 1
	if simvol in downreg:
		flag[2] = 1
	if simvol in cifra:
		flag[3] = 1
if flag[0] and flag[1] and flag[2] and flag[3]:
	print('Correct')
else:
	print('Too weak')


import string
s = input()
print(('Too weak', 'Correct')[len(s) >= 5 and len(set(s) & set(string.ascii_lowercase)) > 0 and (len(set(s) & set(string.ascii_uppercase)) > 0) and (len(set(s) & set(string.digits)) > 0)])


s = input()
yes = True
yes &= len(s) >= 5
yes &= any((c.isupper() for c in s))
yes &= any((c.islower() for c in s))
yes &= any((c.isdigit() for c in s))
if yes:
	print('Correct')
else:
	print('Too weak')


s = input()
(a, b, c) = (0, 0, 0)
if len(s) >= 5:
	a = 1
if s.lower() != s and s.upper() != s:
	b = 1
for i in s:
	if i.isnumeric():
		c = 1
if a and b and c:
	print('Correct')
else:
	print('Too weak')


pw = input()
con1 = False
if len(pw) >= 5:
	con1 = True
con2 = bool([x for x in pw if x.isupper()])
con3 = bool([x for x in pw if x.islower()])
con4 = bool([x for x in pw if x.isdigit()])
if all([con1, con2, con3, con4]):
	print('Correct')
else:
	print('Too weak')


st = input()
if len(st) < 5:
	print('Too weak')
	exit()
for i in st:
	if i.isupper():
		break
else:
	print('Too weak')
	exit()
for i in st:
	if i.islower():
		break
else:
	print('Too weak')
	exit()
for i in st:
	if ord(i) in range(48, 58):
		break
else:
	print('Too weak')
	exit()
print('Correct')


import sys
import math
import itertools
import functools
import collections
import operator
import fileinput
import copy
ORDA = 97

def ii():
	return int(input())

def mi():
	return map(int, input().split())

def li():
	return [int(i) for i in input().split()]

def lcm(a, b):
	return abs(a * b) // math.gcd(a, b)

def revn(n):
	return str(n)[::-1]

def dd():
	return collections.defaultdict(int)

def ddl():
	return collections.defaultdict(list)

def sieve(n):
	if n < 2:
		return list()
	prime = [True for _ in range(n + 1)]
	p = 3
	while p * p <= n:
		if prime[p]:
			for i in range(p * 2, n + 1, p):
				prime[i] = False
		p += 2
	r = [2]
	for p in range(3, n + 1, 2):
		if prime[p]:
			r.append(p)
	return r

def divs(n, start=1):
	r = []
	for i in range(start, int(math.sqrt(n) + 1)):
		if n % i == 0:
			if n / i == i:
				r.append(i)
			else:
				r.extend([i, n // i])
	return r

def divn(n, primes):
	divs_number = 1
	for i in primes:
		if n == 1:
			return divs_number
		t = 1
		while n % i == 0:
			t += 1
			n //= i
		divs_number *= t

def prime(n):
	if n == 2:
		return True
	if n % 2 == 0 or n <= 1:
		return False
	sqr = int(math.sqrt(n)) + 1
	for d in range(3, sqr, 2):
		if n % d == 0:
			return False
	return True

def convn(number, base):
	newnumber = 0
	while number > 0:
		newnumber += number % base
		number //= base
	return newnumber

def cdiv(n, k):
	return n // k + (n % k != 0)
s = input()
if any((c.isupper() for c in s)) and any((c.islower() for c in s)) and any((c.isdigit() for c in s)) and (len(s) > 4):
	print('Correct')
else:
	print('Too weak')


a = input()
if len(a) < 5:
	print('Too weak')
else:
	A = []
	for x in a:
		A.append(x)
	n = 0
	b = 0
	c = 0
	for i in A:
		if ord('a') <= ord(i) <= ord('z'):
			n += 1
		if ord('A') <= ord(i) <= ord('Z'):
			b += 1
		if ord('0') <= ord(i) <= ord('9'):
			c += 1
	if n == 0 or b == 0 or c == 0:
		print('Too weak')
	else:
		print('Correct')


def checkPass(mypass: str) -> bool:
	if len(mypass) < 5:
		return False
	cntlrg = 0
	smlrg = 0
	dig = 0
	for c in mypass:
		if c.isupper():
			cntlrg += 1
		if c.islower():
			smlrg += 1
		if c.isdigit():
			dig += 1
	if cntlrg < 1 or smlrg < 1 or dig < 1:
		return False
	return True
x = input()
if checkPass(x):
	print('Correct')
else:
	print('Too weak')


password = input()
contain_small_letter = False
contain_big_letter = False
contain_num = False
for symbol in password:
	if symbol.isdigit():
		contain_num = True
	elif symbol.lower() == symbol and symbol.isalpha():
		contain_small_letter = True
	elif symbol.upper() == symbol and symbol.isalpha():
		contain_big_letter = True
if contain_small_letter and contain_big_letter and contain_num and (len(password) >= 5):
	print('Correct')
else:
	print('Too weak')


x = input()
l = 0
U = 0
lo = 0
d = 0
if len(x) >= 5:
	l = 1
for i in x:
	if i.isupper():
		U = 1
for i in x:
	if i.islower():
		lo = 1
for i in x:
	if i.isdigit():
		d = 1
if l and U and lo and d:
	print('Correct')
else:
	print('Too weak')


class CodeforcesTask411ASolution:

	def __init__(self):
		self.result = ''
		self.password = ''

	def read_input(self):
		self.password = input()

	def process_task(self):
		correct = True
		if len(self.password) < 5:
			correct = False
		else:
			cond1_met = False
			cond2_met = False
			cond3_met = False
			for c in 'abcdefghijklmnoprstuvwxyz':
				if c in self.password:
					cond1_met = True
					break
			for c in 'abcdefghijklmnoprstuvwxyz'.upper():
				if c in self.password:
					cond2_met = True
					break
			for c in '123456790':
				if c in self.password:
					cond3_met = True
					break
			correct = cond1_met and cond2_met and cond3_met
		if correct:
			self.result = 'Correct'
		else:
			self.result = 'Too weak'

	def get_result(self):
		return self.result
Solution = CodeforcesTask411ASolution()
Solution.read_input()
Solution.process_task()
print(Solution.get_result())


def check(a):
	if len(a) < 5:
		return 0
	does_have_little = 0
	for elem in [chr(i) for i in range(ord('a'), ord('z') + 1)]:
		if elem in a:
			does_have_little = 1
			break
	if not does_have_little:
		return 0
	does_have_big = 0
	for elem in [chr(i) for i in range(ord('A'), ord('Z') + 1)]:
		if elem in a:
			does_have_big = 1
			break
	if not does_have_big:
		return 0
	number = 0
	for elem in [chr(i) for i in range(ord('0'), ord('9') + 1)]:
		if elem in a:
			number = 1
			break
	if not number:
		return 0
	return 1
a = input()
if check(a):
	print('Correct')
else:
	print('Too weak')


import re
n = input()
x = re.findall('\\d', n)
y = re.findall('[a-z]', n)
z = re.findall('[A-Z]', n)
if len(n) >= 5 and x and y and z:
	print('Correct')
else:
	print('Too weak')


n = input()
print(['Too weak', 'Correct'][len(n) >= 5 and any([x for x in n if x in 'qwertyuiopasdfghjklzxcvbnm']) and any([x for x in n if x in 'QWERTYUIOPASDFGHJKLZXCVBNM']) and any([x for x in n if x in '1234567890'])])


str = input()
small = 0
big = 0
num = 0
for i in range(10):
	if chr(i + ord('0')) in str:
		num = 1
for i in range(26):
	if chr(i + ord('a')) in str:
		small = 1
for i in range(26):
	if chr(i + ord('A')) in str:
		big = 1
if len(str) >= 5 and big and small and num:
	print('Correct')
else:
	print('Too weak')


def small(c):
	return 'a' <= c <= 'z'

def big(c):
	return 'A' <= c <= 'Z'

def digit(c):
	return '0' <= c <= '9'
line = input()
check = [0] * 4
if len(line) >= 5:
	for elem in line:
		if small(elem):
			check[1] = 1
		if big(elem):
			check[2] = 1
		if digit(elem):
			check[3] = 1
if sum(check) == 3:
	print('Correct')
else:
	print('Too weak')


y = input()
c = 0
r = 0
f = 0
o = 0
for i in y:
	if ord(i) >= 65 and ord(i) <= 90:
		c += 1
	elif ord(i) >= 97 and ord(i) <= 122:
		r += 1
	elif ord(i) >= 48 and ord(i) <= 57:
		o += 1
if c >= 1 and r >= 1 and (o >= 1) and (len(y) >= 5):
	print('Correct')
else:
	print('Too weak')


s = input()
(u, l, k) = (False, False, False)
for i in s:
	if i.isupper():
		u = True
	if i.islower():
		l = True
	if i.isdigit():
		k = True
if u and k and l and (len(s) >= 5):
	print('Correct')
else:
	print('Too weak')


s = input()
left_a = ord('a')
right_a = ord('z')
left_A = ord('A')
right_A = ord('Z')
left_1 = ord('0')
right_1 = ord('9')
x = 0
y = 0
z = 0
for elem in s:
	if left_a <= ord(elem) <= right_a:
		x += 1
	elif left_A <= ord(elem) <= right_A:
		y += 1
	elif left_1 <= ord(elem) <= right_1:
		z += 1
if len(s) >= 5 and x > 0 and (y > 0) and (z > 0):
	print('Correct')
else:
	print('Too weak')


def is_small(letter):
	if letter >= 'a' and letter <= 'z':
		return True
	else:
		return False

def is_big(letter):
	if letter >= 'A' and letter <= 'Z':
		return True
	else:
		return False

def is_digit(letter):
	if letter >= '0' and letter <= '9':
		return True
	else:
		return False

def is_strong(to_check):
	length = len(to_check)
	at_least_big = False
	at_least_small = False
	at_least_digit = False
	for i in range(len(to_check)):
		if is_small(to_check[i]):
			at_least_small = True
		if is_big(to_check[i]):
			at_least_big = True
		if is_digit(to_check[i]):
			at_least_digit = True
		if at_least_big == True and at_least_small == True and (at_least_digit == True) and (length >= 5):
			return True
	return False
password = input()
if is_strong(password):
	print('Correct')
else:
	print('Too weak')


s = input()
(c, d, e) = (0, 0, 0)
if len(s) < 5:
	print('Too weak')
else:
	for i in s:
		if i.isdigit():
			c += 1
		if i.isupper():
			d += 1
		if i.islower():
			e += 1
	if c >= 1 and d >= 1 and (e >= 1):
		print('Correct')
	else:
		print('Too weak')


s = input()
n = len(s)
count = count1 = count2 = 0
digits = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
if n >= 5:
	for i in range(n):
		if s[i] in digits:
			count += 1
		elif s[i] == s[i].upper() and s[i].isalpha():
			count1 += 1
		elif s[i] == s[i].lower() and s[i].isalpha():
			count2 += 1
		if count > 0 and count1 > 0 and (count2 > 0):
			break
	if count > 0 and count1 > 0 and (count2 > 0):
		print('Correct')
	else:
		print('Too weak')
else:
	print('Too weak')


s = str(input())
l = 0
S = 0
d = 0
for i in s:
	if i >= 'a' and i <= 'z':
		S += 1
	if i >= 'A' and i <= 'Z':
		l += 1
	if i >= '0' and i <= '9':
		d += 1
print('Correct' if len(s) > 4 and S > 0 and (l > 0) and (d > 0) else 'Too weak')


def solve(s):
	if len(s) < 5:
		return 'Too weak'
	capital = 0
	lower = 0
	digit = 0
	capitals = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
	lowercase = 'abcdefghijklmnopqrstuvwxyz'
	digits = '1234567890'
	for i in range(len(s)):
		if s[i] in capitals:
			capital += 1
		elif s[i] in lowercase:
			lower += 1
		elif s[i] in digits:
			digit += 1
	if capital > 0 and lower > 0 and (digit > 0):
		return 'Correct'
	return 'Too weak'
s = input()
print(solve(s))


(S, Check) = (input(), [False] * 3)
for i in S:
	if ord(i) in range(ord('A'), ord('Z') + 1):
		Check[0] = True
	if ord(i) in range(ord('a'), ord('z') + 1):
		Check[1] = True
	if ord(i) in range(ord('0'), ord('9') + 1):
		Check[2] = True
print('Correct' if len(S) >= 5 and Check.count(True) == 3 else 'Too weak')


(s, l, u, d) = (input(), 0, 0, 0)
for i in s:
	u += i.isupper()
	l += i.islower()
	d += i.isdigit()
print(['Too weak', 'Correct'][(len(s) >= 5) * u * l * d != 0])


s = input().strip()
if len(s) >= 5 and s != s.lower() and (s != s.upper()):
	for i in range(0, 10):
		if s.find(str(i)) != -1:
			print('Correct')
			break
	else:
		print('Too weak')
else:
	print('Too weak')


s = input()
t = '!?.,_'
if any((x.isupper() for x in s)) and any((x.islower() for x in s)) and any((x.isdigit() for x in s)) and (len(s) >= 5):
	print('Correct')
else:
	print('Too weak')


s = input()
nl = 0
nc = 0
ns = 0
nd = 0
if len(s) >= 5:
	nl = 1
	np = 0
	for i in s:
		c = ord(i)
		if c >= 65 and c <= 90:
			nc = 1
		elif c >= 97 and c <= 122:
			ns = 1
		elif i in '0123456789':
			nd = 1
		if nc == 1 and ns == 1 and (nd == 1):
			print('Correct')
			np = 1
			break
	if np == 0:
		print('Too weak')
else:
	print('Too weak')


p = input()
if len(p) < 5:
	print('Too weak')
	exit()
lower = 'abcdefghijklmnopqrstuvwxyz'
upper = lower.upper()
digit = '1234567890'
for check in [lower, upper, digit]:
	valid = False
	for l in check:
		if l in p:
			valid = True
			break
	if not valid:
		print('Too weak')
		exit()
print('Correct')


t1 = t2 = t3 = False
s = input()
for sym in s:
	if 'a' <= sym <= 'z':
		t1 = True
	if 'A' <= sym <= 'Z':
		t2 = True
	if sym.isdigit():
		t3 = True
if t1 and t2 and t3 and (len(s) >= 5):
	print('Correct')
else:
	print('Too weak')


s = input()
letters_upper = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
letters_lower = 'abcdefghijklmnopqrstuvwxyz'
nums = '0123456789'
symbols = '!?.,_'
a1 = a2 = a3 = 0
if len(s) >= 5:
	for a in s:
		if a in letters_upper:
			a1 = 1
			continue
		if a in letters_lower:
			a2 = 1
			continue
		if a in nums:
			a3 = 1
			continue
		if a1 + a2 + a3 == 3:
			break
if a1 + a2 + a3 == 3:
	print('Correct')
else:
	print('Too weak')


import math, itertools, fractions, heapq, collections, bisect, sys, queue, copy
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def LI():
	return [int(x) for x in sys.stdin.readline().split()]

def I():
	return int(sys.stdin.readline())

def F():
	return float(sys.stdin.readline())

def LS():
	return sys.stdin.readline().split()

def S():
	return input()
alf1 = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
alf2 = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z']

def main():
	s = list(S())
	if len(s) < 5:
		return 'Too weak'
	num_list = [str(x) for x in range(10)]
	f1 = f2 = f3 = False
	for x in s:
		if x in alf1:
			f1 = True
		if x in alf2:
			f2 = True
		if x in num_list:
			f3 = True
	if not f1 or not f2 or (not f3):
		return 'Too weak'
	return 'Correct'
print(main())


from sys import stdin

def get_ints():
	return list(map(int, stdin.readline().strip().split()))
s = input()
if len(s) >= 5:
	lower = False
	for i in s:
		if i.islower():
			lower = True
			break
	upper = False
	for i in s:
		if i.isupper():
			upper = True
			break
	num = False
	for i in s:
		if i.isnumeric():
			num = True
			break
	if lower and upper and num:
		print('Correct')
		exit()
print('Too weak')


s = input()
large = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
small = 'abcdefghijklmnopqrstuvwxyz'
digit = '0123456789'
cnd1 = False
cnd2 = False
cnd3 = False
cnd4 = False
for i in range(len(s)):
	if s[i] in large:
		cnd2 = True
	if s[i] in small:
		cnd3 = True
	if s[i] in digit:
		cnd4 = True
if len(s) >= 5:
	cnd1 = True
if cnd1 and cnd2 and cnd3 and cnd4:
	print('Correct')
else:
	print('Too weak')


p = input()
small = 0
large = 0
digit = 0
for i in p:
	if i.islower():
		small = 1
	if i.isupper():
		large = 1
	if i.isdigit():
		digit = 1
if len(p) >= 5 and small == 1 and (large == 1) and (digit == 1):
	print('Correct')
else:
	print('Too weak')


pawd = str(input())
num = 0
for x in pawd:
	if x.isupper() == True:
		num += 1
		break
for y in pawd:
	if y.islower() == True:
		num += 1
		break
for z in pawd:
	if z.isdigit() == True:
		num += 1
		break
if num == 3 and len(pawd) > 4:
	print('Correct')
else:
	print('Too weak')


s = input()
digit = 0
char = 0
large = 0
small = 0
if len(s) < 5:
	print('Too weak')
	exit()
for i in s:
	if i.isdigit():
		digit += 1
	elif i.isupper():
		large += 1
	elif i.islower():
		small += 1
	else:
		char += 1
if large >= 1 and small >= 1 and (digit >= 1):
	print('Correct')
else:
	print('Too weak')


import collections
import time
import os
import sys
import bisect
import heapq
from typing import List

def check(password):
	if len(password) < 5:
		return False
	hasUpper = any([v in [chr(ord('A') + i) for i in range(26)] for v in password])
	hasLower = any([v in [chr(ord('a') + i) for i in range(26)] for v in password])
	if not hasLower or not hasUpper:
		return False
	hasDigit = any([v in [str(i) for i in range(10)] for v in password])
	if not hasDigit:
		return False
	return True
password = input()
valid = check(password)
print('Correct' if valid else 'Too weak')


def main():
	a = input()
	lower = False
	upper = False
	digit = False
	if len(a) >= 5:
		for c in a:
			lower = lower or c.islower()
			upper = upper or c.isupper()
			digit = digit or c.isdigit()
		if lower and upper and digit:
			print('Correct')
		else:
			print('Too weak')
	else:
		print('Too weak')
main()


import re
S = input()
if len(S) >= 5 and re.search('[A-Z]', S) and re.search('[a-z]', S) and re.search('[0-9]', S):
	print('Correct')
else:
	print('Too weak')


s = list(input())
if len(s) < 5:
	print('Too weak')
else:
	alfie = 'abcdefghijklmnopqrstuvwxyz'
	ALFIE = alfie.upper()
	nums = '0123456789'
	i = 0
	(alfiec, ALFIEc, numsc) = (0, 0, 0)
	while i < len(s):
		if s[i] in alfie:
			alfiec += 1
		elif s[i] in ALFIE:
			ALFIEc += 1
		elif s[i] in nums:
			numsc += 1
		if numsc and alfiec and ALFIEc:
			break
		i += 1
	if numsc and alfiec and ALFIEc:
		print('Correct')
	else:
		print('Too weak')


from sys import stdin
import re

def main():
	inp = stdin
	pasword = inp.readline().strip()
	minuscula = re.findall('[a-z]', pasword)
	mayuscula = re.findall('[A-Z]', pasword)
	numero = re.findall('[0-9]', pasword)
	if len(pasword) >= 5:
		if len(minuscula) >= 1:
			if len(mayuscula) >= 1:
				if len(numero) >= 1:
					print('Correct')
				else:
					print('Too weak')
			else:
				print('Too weak')
		else:
			print('Too weak')
	else:
		print('Too weak')
main()


s = input().rstrip()
S = set(s)
A = set('QWERTYUIOPASDFGHJKLZXCVBNM')
a = set('qwertyuiopasdfghjklzxcvbnm')
a0 = set('1234567890')
if len(s) >= 5 and A & S != set() and (a & S != set()) and (a0 & S != set()):
	print('Correct')
else:
	print('Too weak')


import re
s = input()
print(['Too weak', 'Correct'][all([re.search(t, s) for t in ['.{5}', '[a-z]', '[A-Z]', '\\d']])])


a = input()
c = 0
s = 0
n = 0
i = 0
while (c == 0 or s == 0 or n == 0) and i < len(a):
	if a[i] >= 'A' and a[i] <= 'Z':
		c = 1
	if a[i] >= 'a' and a[i] <= 'z':
		s = 1
	if a[i] >= '0' and a[i] <= '9':
		n = 1
	i = i + 1
if c == 0 or s == 0 or n == 0 or (len(a) < 5):
	print('Too weak')
else:
	print('Correct')


big = False
low = False
digit = False
word = input()
for i in word:
	if len(word) < 5:
		print('Too weak')
		exit()
	if i.isupper():
		big = True
	if i.islower():
		low = True
	if i.isdigit():
		digit = True
if big and low and digit:
	print('Correct')
	exit()
print('Too weak')


import re
st = input().rstrip()
y = re.search('^(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z]).{5,}$', st)
if y == None:
	print('Too weak')
else:
	print('Correct')


s = input()
count = count1 = count2 = 0
if len(s) >= 5:
	for i in range(len(s)):
		if s[i].isupper() and count == 0:
			count += 1
		if s[i].islower() and count1 == 0:
			count1 += 1
		if s[i].isdigit() and count2 == 0:
			count2 += 1
if count > 0 and count1 > 0 and (count2 > 0):
	print('Correct')
else:
	print('Too weak')


import re
a1 = re.compile('[a-z]')
a2 = re.compile('[A-Z]')
a3 = re.compile('[0-9]')
s = input()
if len(s) >= 5:
	s = list(s)
	ar = [0, 0, 0]
	for i in s:
		if a1.match(i) != None:
			ar[0] += 1
	for i in s:
		if a2.match(i) != None:
			ar[1] += 1
	for i in s:
		if a3.match(i) != None:
			ar[2] += 1
	if ar[0] != 0 and ar[1] != 0 and (ar[2] != 0):
		print('Correct')
	else:
		print('Too weak')
else:
	print('Too weak')


pw = input()
if len(pw) < 5:
	pw_good = False
elif len([char for char in pw if char.isupper()]) < 1:
	pw_good = False
elif len([char for char in pw if char.islower()]) < 1:
	pw_good = False
elif len([char for char in pw if char.isnumeric()]) < 1:
	pw_good = False
else:
	pw_good = True
if pw_good:
	print('Correct')
else:
	print('Too weak')


line = input()
a = 0
b = 0
c = 0
if len(line) < 5:
	print('Too weak')
else:
	for i in range(len(line)):
		if line[i].isupper() == True:
			a = 1
		if line[i].islower() == True:
			b = 1
		if line[i].isdigit() == True:
			c = 1
	if a == 1 and b == 1 and (c == 1):
		print('Correct')
	else:
		print('Too weak')


small = 'abcdefghijklmnopqrstuvwxyz'
large = small.upper()
number = '0123456789'
other = '!?.,_'
s = input()
strength = 0
for i in s:
	if i in small:
		strength += 1
		break
for i in s:
	if i in large:
		strength += 1
		break
for i in s:
	if i in number:
		strength += 1
		break
if len(s) >= 5:
	strength += 1
if strength == 4:
	print('Correct')
else:
	print('Too weak')


import re
passwd = input()
result = True
if len(passwd) < 5:
	result = False
elif re.findall('[A-Z]', passwd) == []:
	result = False
elif re.findall('[a-z]', passwd) == []:
	result = False
elif re.findall('[0-9]', passwd) == []:
	result = False
if result:
	print('Correct')
else:
	print('Too weak')


isLength = False
isLarge = False
isSmall = False
isDigit = False
password = input()
if len(password) >= 5:
	isLength = True
for m in password:
	if m.isupper():
		isLarge = True
	if m.islower():
		isSmall = True
	if m.isdigit():
		isDigit = True
if isSmall and isDigit and isLarge and isLength:
	print('Correct')
else:
	print('Too weak')


a = str(input(''))
if any((x.isupper() for x in a)) and any((x.islower() for x in a)) and any((x.isdigit() for x in a)) and (len(a) >= 5):
	print('CORRECT'.lower().capitalize())
else:
	print('TOO WEAK'.lower().capitalize())


p = input()
if len(p) >= 5:
	if p != p.upper():
		if p != p.lower():
			for c in p:
				if c in '1 2 3 4 5 6 7 8 9 0'.split():
					print('Correct')
					exit(0)
print('Too weak')


s = input()
a = False
b = False
c = False
d = False
if len(s) >= 5:
	a = True
for i in range(len(s)):
	if ord(s[i]) >= ord('A') and ord(s[i]) <= ord('Z'):
		b = True
	if ord(s[i]) >= ord('a') and ord(s[i]) <= ord('z'):
		c = True
	if ord(s[i]) >= ord('1') and ord(s[i]) <= ord('9'):
		d = True
if a and b and c and d:
	print('Correct')
else:
	print('Too weak')


password = input()
if any((c.isupper() for c in password)) and len(password) > 4 and any((c.islower() for c in password)) and any((c.isdigit() for c in password)):
	print('Correct')
else:
	print('Too weak')


n = str(input())
if len(n) >= 5:
	hasLarge = False
	hasSmall = False
	hasDigit = False
	for i in n:
		if i.isalpha() and i == i.upper():
			hasLarge = True
		if i.isalpha() and i == i.lower():
			hasSmall = True
		try:
			temp = int(i)
			hasDigit = True
		except ValueError:
			continue
	if hasDigit and hasSmall and hasLarge:
		print('Correct')
	else:
		print('Too weak')
else:
	print('Too weak')


from functools import reduce
from operator import *
from math import *
from sys import *
from string import *
setrecursionlimit(10 ** 7)
dX = [0, 0, 1, -1, 1, -1, 1, -1]
dY = [1, -1, 0, 0, 1, -1, -1, 1]
RI = lambda : list(map(int, input().split()))
RS = lambda : input().rstrip().split()
s = RS()[0]
if len(s) >= 5 and any((i in ascii_lowercase for i in s)) and any((i in ascii_uppercase for i in s)) and any((i in digits for i in s)):
	print('Correct')
else:
	print('Too weak')


s_lower = 'abcdefghijklmnopqrstuvwxyz'
s_upper = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
digits = '0123456789'

def parol(s):
	(count1, count2, count3) = (0, 0, 0)
	for elem in s:
		if elem in s_lower:
			count1 += 1
		if elem in s_upper:
			count2 += 1
		if elem in digits:
			count3 += 1
	if count1 >= 1 and count2 >= 1 and (count3 >= 1) and (len(s) >= 5):
		return 'Correct'
	return 'Too weak'
print(parol(input()))


string = input()
(length, low, high, num) = (False, False, False, False)
for i in string:
	if i.islower():
		low = True
	elif i.isupper():
		high = True
	elif i.isnumeric():
		num = True
if len(string) >= 5:
	length = True
if length and low and high and num:
	print('Correct')
else:
	print('Too weak')


import re
s = input()
print('Correct' if all([re.search('[0-9]', s), re.search('[a-z]', s), re.search('[A-Z]', s), len(s) >= 5]) else 'Too weak')


s = input()
print(('Too weak', 'Correct')[len(s) > 4 and any((ord(i) in range(65, 92) for i in s)) and any((ord(i) in range(97, 124) for i in s)) and any((i in '1234567890' for i in s))])


p = input()
u = []
l = []
d = []
for i in p:
	if i.islower():
		l.append(i)
	elif i.isupper():
		u.append(i)
	elif i.isdigit():
		d.append(i)
if len(p) >= 5 and len(l) > 0 and (len(u) > 0) and (len(d) > 0):
	print('Correct')
else:
	print('Too weak')


line = input()
length = False
little = False
big = False
number = False
length = len(line) > 4
for symbol in line:
	if '0' <= symbol <= '9':
		number = True
	elif 'a' <= symbol <= 'z':
		little = True
	elif 'A' <= symbol <= 'Z':
		big = True
if length and little and big and number:
	print('Correct')
else:
	print('Too weak')


s = input()
got_low = False
got_high = False
got_digit = False
for char in s:
	if 'a' <= char <= 'z':
		got_low = True
	if 'A' <= char <= 'Z':
		got_high = True
	if '0' <= char <= '9':
		got_digit = True
if got_low and got_high and got_digit and (len(s) >= 5):
	print('Correct')
else:
	print('Too weak')


def check(a):
	res = ['Too weak', 'Correct']
	r = 0
	if len(a) < 5:
		return res[r]
	w = [False] * 3
	capitals = [chr(x) for x in range(ord('A'), ord('Z') + 1)]
	letters = [chr(x) for x in range(ord('a'), ord('z') + 1)]
	digits = [chr(x) for x in range(ord('0'), ord('9') + 1)]
	for i in a:
		if i in capitals:
			w[0] = True
		if i in letters:
			w[1] = True
		if i in digits:
			w[2] = True
	r = all((x for x in w))
	return res[r]
t = input()
print(check(t))


s = input()
a = False
b = False
c = False
d = False
if len(s) >= 5:
	a = True
for i in 'abcdefghijklmnopqrstuvwxyz':
	if i in s:
		b = True
	if i.upper() in s:
		c = True
for i in '0123456789':
	if i in s:
		d = True
if a and b and c and d:
	print('Correct')
else:
	print('Too weak')


b = '1234567890'
b1 = 'qwertyuiopasdfghjklzxcvbnm'
b2 = b1.upper()
a = input()
c = ''
c1 = ''
c2 = ''
for i in range(len(a)):
	if a[i] in b:
		c = '1'
	elif a[i] in b1:
		c1 = '1'
	elif a[i] in b2:
		c2 = '1'
if c + c1 + c2 == '111' and len(a) >= 5:
	print('Correct')
else:
	print('Too weak')


s = input()
flag1 = False
flag2 = False
flag3 = False
for i in s:
	if 'a' <= i <= 'z':
		flag1 = True
	if 'A' <= i <= 'Z':
		flag2 = True
	if '0' <= i <= '9':
		flag3 = True
if len(s) >= 5 and flag1 and flag2 and flag3:
	print('Correct')
else:
	print('Too weak')


pwd = input()
if len(pwd) < 5:
	print('Too weak')
else:
	hasUpper = False
	hasLower = False
	hasDigit = False
	for c in pwd:
		if c.islower():
			hasLower = True
		if c.isupper():
			hasUpper = True
		if c.isdigit():
			hasDigit = True
	if hasUpper and hasDigit and hasLower:
		print('Correct')
	else:
		print('Too weak')


import re
check = re.compile('(?=.*[0-9])(?=.*[A-Z])(?=.*[a-z])')
pas = input()
cur = check.match(pas)
if cur and len(pas) >= 5:
	print('Correct')
else:
	print('Too weak')


password_input = input()
password_list = []
for z in range(0, len(password_input)):
	password_list.insert(z, password_input[z])

def is_good_password(password_list):
	number_of_uppercase = 0
	number_of_lowercase = 0
	number_of_digit = 0
	number_of_speacial_character = 0
	if len(password_list) < 5:
		return 'Too weak'
	for i in password_list:
		if i.isupper():
			number_of_uppercase += 1
		elif i.islower():
			number_of_lowercase += 1
		elif i in '0123456789':
			number_of_digit += 1
		elif i in '!?.,_':
			number_of_speacial_character += 1
	if number_of_uppercase and number_of_lowercase and (number_of_digit >= 1):
		return 'Correct'
	else:
		return 'Too weak'
print(is_good_password(password_list))


(S, Check) = (input(), [False] * 3)
for i in S:
	if i.islower():
		Check[0] = True
	if i.isupper():
		Check[1] = True
	if i.isdigit():
		Check[2] = True
print('Correct' if len(S) >= 5 and Check.count(True) == 3 else 'Too weak')


def main():
	a1 = 'poiuytrewqlkjhgfdsamnbvcxz'
	a2 = 'POIUYTREWQLKJHGFDSAMNBVCXZ'
	a3 = '0987654321'
	s = input()
	ind0 = ind1 = ind2 = ind3 = False
	ind0 = len(s) >= 5
	for c in s:
		ind1 |= c in a1
		ind2 |= c in a2
		ind3 |= c in a3
	if ind0 & ind1 & ind2 & ind3:
		print('Correct')
	else:
		print('Too weak')
main()


pw = str(input())

def search(l, r):
	for j in range(len(pw)):
		if ord(pw[j]) >= l and ord(pw[j]) <= r:
			return True
	return False
output = 'Too weak'
if len(pw) > 4 and search(97, 122) == True and (search(65, 90) == True) and (search(48, 57) == True):
	output = 'Correct'
print(output)


(n, l, h) = (False, False, False)
(ord_a, ord_z, ord_A, ord_Z, ord_0, ord_9) = (ord('a'), ord('z'), ord('A'), ord('Z'), ord('0'), ord('9'))
cnt = 0
for elm in input():
	ord_elm = ord(elm)
	if ord_a <= ord_elm <= ord_z:
		l = True
	elif ord_A <= ord_elm <= ord_Z:
		h = True
	elif ord_0 <= ord_elm <= ord_9:
		n = True
	cnt += 1
print('Correct' if n and l and h and (cnt >= 5) else 'Too weak')


n = input()
if len(n) < 5:
	print('Too weak')
else:
	y = [0] * 3
	for k in range(len(n)):
		if 48 <= ord(n[k]) <= 57:
			y[0] += 1
		if 97 <= ord(n[k]) <= 122:
			y[1] += 1
		if 65 <= ord(n[k]) <= 90:
			y[2] += 1
	if min(y) >= 1:
		print('Correct')
	else:
		print('Too weak')


p = input()
l = s = d = False
for c in p:
	if c.isupper():
		l = True
	if c.islower():
		s = True
	if c.isdigit():
		d = True
print('Correct' if len(p) >= 5 and l and s and d else 'Too weak')


import sys
s = str(input())
t2 = 0
t3 = 0
t4 = 0
if len(s) < 5:
	print('Too weak')
	sys.exit(0)
for i in range(len(s)):
	if 'a' <= s[i] <= 'z':
		t2 = 1
	if 'A' <= s[i] <= 'Z':
		t3 = 1
	if '0' <= s[i] <= '9':
		t4 = 1
if t2 & t3 & t4:
	print('Correct')
else:
	print('Too weak')


chars = list(input())
length = False
upper = False
lower = False
digit = False
if len(chars) >= 5:
	length = True
for char in chars:
	if char.islower() == True:
		lower = True
	elif char.isupper() == True:
		upper = True
	elif char.isdigit() == True:
		digit = True
if length == True and upper == True and (lower == True) and (digit == True):
	print('Correct')
else:
	print('Too weak')


y = [i for i in input()]
x = set(y)
num = set([i for i in '0123456789'])
A = set([i for i in 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'])
a = set([i for i in 'abcdefghijklmnopqrstuvwxyz'])
if len(y) >= 5 and len(A.intersection(x)) > 0 and (len(a.intersection(x)) > 0) and (len(num.intersection(x)) > 0):
	print('Correct')
else:
	print('Too weak')


s = str(input())
L = list(s)
if any((e.isupper() for e in L)) and any((e.islower() for e in L)) and any((e.isnumeric() for e in L)) and (len(L) >= 5):
	print('Correct')
else:
	print('Too weak')


st = input()
num = 0
for x in st:
	if x.isupper() and len(st) >= 5:
		num += 2
		break
for y in st:
	if y.islower() and len(st) >= 5:
		num += 1
		break
for z in st:
	if z.isdigit() and len(st) >= 5:
		num += 1
		break
if num == 4:
	print('Correct')
else:
	print('Too weak')


a = input()
if len(a) >= 5:
	f1 = False
	f2 = False
	f3 = False
	for i in range(len(a)):
		if 65 <= ord(a[i]) <= 90:
			f1 = True
		elif 97 <= ord(a[i]) <= 122:
			f2 = True
		elif 48 <= ord(a[i]) <= 57:
			f3 = True
	if f1 and f2 and f3:
		print('Correct')
	else:
		print('Too weak')
else:
	print('Too weak')


parol = input()
a1 = False
a2 = False
a3 = False
if len(parol) >= 5:
	for i in range(len(parol)):
		if ord('A') <= ord(parol[i]) <= ord('Z'):
			a1 = True
		elif ord('a') <= ord(parol[i]) <= ord('z'):
			a2 = True
		elif ord('0') <= ord(parol[i]) <= ord('9'):
			a3 = True
if a1 and a2 and a3:
	print('Correct')
else:
	print('Too weak')


flA = False
fla = False
flts = False
s = input()
for ch in s:
	if ch.isdigit():
		flts = True
	elif ord('A') <= ord(ch) <= ord('Z'):
		fla = True
	elif ord('a') <= ord(ch) <= ord('z'):
		flA = True
if flts and fla and flA and (len(s) >= 5):
	print('Correct')
else:
	print('Too weak')


import re
print('Correct' if re.match('(?=.{5,})(?=.*\\d)(?=.*[a-z]).*[A-Z].*', input()) else 'Too weak')


s = input()
a = list(s)
l = len(s)
if l >= 5:
	caps = 0
	s = 0
	n = 0
	for i in range(len(a)):
		if caps > 0 and s > 0 and (n > 0):
			break
		if a[i] >= 'a' and a[i] <= 'z':
			s = s + 1
		elif a[i] >= 'A' and a[i] <= 'Z':
			caps = caps + 1
		elif a[i] >= '0' and a[i] <= '9':
			n = n + 1
	if caps > 0 and s > 0 and (n > 0):
		print('Correct')
	else:
		print('Too weak')
else:
	print('Too weak')


s = input()
arr = list(s)
con1 = list(filter(lambda x: x >= 'A' and x <= 'Z', arr))
if len(con1) > 0 and len(arr) >= 5:
	con2 = list(filter(lambda x: x >= 'a' and x <= 'z', arr))
	if len(con2) > 0:
		con3 = list(filter(lambda x: x >= '0' and x <= '9', arr))
		if len(con3) > 0:
			print('Correct')
		else:
			print('Too weak')
	else:
		print('Too weak')
else:
	print('Too weak')


a = input()
k = 0
if len(a) >= 5:
	k += 1
	for i in range(len(a)):
		if 65 <= ord(a[i]) <= 90:
			k += 1
			break
	for i in range(len(a)):
		if 97 <= ord(a[i]) <= 122:
			k += 1
			break
	for i in range(len(a)):
		if 48 <= ord(a[i]) <= 57:
			k += 1
			break
if k == 4:
	print('Correct')
else:
	print('Too weak')


a = input()
(q, w, e, r) = (0, 0, 0, 0)
if len(a) > 4:
	r = 1
for i in a:
	if i.isupper():
		q = 1
	elif i.islower():
		w = 1
	elif i.isdigit():
		e = 1
if min(q, w, e, r) == 1:
	print('Correct')
else:
	print('Too weak')


p = input()
b = []
for i in p:
	b.append(ord(i))
f = 0
if len(b) >= 5:
	f = 1
l = s = d = 0
for i in b:
	if i in range(65, 91):
		l = 1
	elif i in range(97, 123):
		s = 1
	elif i in range(48, 58):
		d = 1
if f == l == s == d == 1:
	print('Correct')
else:
	print('Too weak')


import string
s = input()
f1 = f2 = f3 = False
for c in s:
	if c in string.ascii_lowercase:
		f1 = True
	if c in string.ascii_uppercase:
		f2 = True
	if c in string.digits:
		f3 = True
if len(s) >= 5 and f1 and f2 and f3:
	print('Correct')
else:
	print('Too weak')


from math import *
from cmath import *
from itertools import *
from decimal import *
from fractions import *
from sys import *
from types import CodeType, new_class
s = input()
a = list(s)
l = len(s)
if l >= 5:
	caps = 0
	s = 0
	n = 0
	for i in range(len(a)):
		if caps > 0 and s > 0 and (n > 0):
			break
		if a[i] >= 'a' and a[i] <= 'z':
			s = s + 1
		elif a[i] >= 'A' and a[i] <= 'Z':
			caps = caps + 1
		elif a[i] >= '0' and a[i] <= '9':
			n = n + 1
	if caps > 0 and s > 0 and (n > 0):
		print('Correct')
	else:
		print('Too weak')
else:
	print('Too weak')


s = input()
Cap = Sma = Sym = Num = 0
if len(s) < 5:
	print('Too weak')
else:
	for i in s:
		d = ord(i)
		if d >= 65 and d <= 90:
			Cap += 1
		elif d >= 97 and d <= 122:
			Sma += 1
		elif d >= 48 and d <= 57:
			Num += 1
		else:
			Sym += 1
	if Cap > 0 and Sma > 0 and (Num > 0):
		print('Correct')
	else:
		print('Too weak')


s = input()
_len = False
_az = False
_AZ = False
_19 = False
if len(s) >= 5:
	_len = True
for i in range(len(s)):
	if s[i] in 'QWERTYUIOPASDFGHJKLZXCVBNM':
		_AZ = True
	if s[i] in 'qwertyuiopasdfghjklzxcvbnm':
		_az = True
	if s[i] in '1234567890':
		_19 = True
if _len and _AZ and _az and _19:
	print('Correct')
else:
	print('Too weak')


s = input()
(large_cnt, small_cnt, digit_cnt) = (0, 0, 0)
for x in s:
	if x.isupper():
		large_cnt += 1
	elif x.islower():
		small_cnt += 1
	elif x.isdigit():
		digit_cnt += 1
if len(s) >= 5 and large_cnt >= 1 and (small_cnt >= 1) and (digit_cnt >= 1):
	print('Correct')
else:
	print('Too weak')


def main():
	OK_MESSAGE = 'Correct'
	ERROR_MESSAGE = 'Too weak'
	BIG_ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
	ALPHABET = 'abcdefghijklmnopqrstuvwxyz'
	LEN_ABC = 26
	NUMBERS = '1234567890'
	NUMBER_NUMBERS = 10
	MIN_LENGTH = 5
	flag = True
	password = input()
	errors = 0
	if len(password) < 5:
		flag = False
	for i in range(LEN_ABC):
		if not BIG_ALPHABET[i] in password:
			errors += 1
	if errors == 26:
		flag = False
	errors = 0
	for i in range(LEN_ABC):
		if not ALPHABET[i] in password:
			errors += 1
	if errors == 26:
		flag = False
	errors = 0
	for i in range(NUMBER_NUMBERS):
		if not NUMBERS[i] in password:
			errors += 1
	if errors == 10:
		flag = False
	if flag:
		print(OK_MESSAGE)
	else:
		print(ERROR_MESSAGE)
main()


s = input()
l = len(s)
if l >= 5:
	A = 0
	a = 0
	d = 0
	for i in s:
		if A > 0 and a > 0 and (d > 0):
			break
		if i >= 'a' and i <= 'z':
			a = a + 1
		elif i >= 'A' and i <= 'Z':
			A += 1
		try:
			k = int(i)
			d = d + 1
		except:
			pass
	if A > 0 and a > 0 and (d > 0):
		print('Correct')
	else:
		print('Too weak')
else:
	print('Too weak')


n = input()
(flag1, flag2, flag3, flag4) = (0, 0, 0, 0)
if len(n) >= 5:
	flag1 = 1
for i in n:
	if i.isdigit():
		flag2 = 1
	if i.swapcase().isupper():
		flag3 = 1
	if i.swapcase().islower():
		flag4 = 1
if flag1 and flag2 and flag3 and flag4:
	print('Correct')
else:
	print('Too weak')


import sys
import math
st = sys.stdin.readline()
l = 0
a1 = 0
a2 = 0
a3 = 0
for i in st:
	v = ord(i)
	if v >= 48 and v <= 57:
		a1 = 1
	if v >= 65 and v <= 90:
		a2 = 1
	if v >= 97 and v <= 122:
		a3 = 1
	l += 1
if a1 == 1 and a2 == 1 and (a3 == 1) and (l - 1 >= 5):
	print('Correct')
else:
	print('Too weak')


line = input()

def has_lower(test_string):
	for i in test_string:
		if i.islower() == True:
			return True
	return False

def has_digit(test_string):
	for i in test_string:
		if i.isdigit() == True:
			return True
	return False

def has_upper(test_string):
	for i in test_string:
		if i.isupper() == True:
			return True
	return False
if len(line) >= 5 and has_upper(line) == True and (has_lower(line) == True) and has_digit(line):
	print('Correct')
else:
	print('Too weak')


password = input()
a = b = c = 0
if len(password) > 4:
	for i in password:
		if a == 0 and ord(i) in range(48, 58):
			a = 1
		if b == 0 and ord(i) in range(65, 91):
			b = 1
		if c == 0 and ord(i) in range(97, 123):
			c = 1
		if a + b + c > 2:
			print('Correct')
			return
print('Too weak')


password = input()
cap = False
sml = False
dig = False
ln = False
if len(password) >= 5:
	for i in password:
		if i.isupper():
			cap = True
		if i.islower():
			sml = True
		if i in '1234567890':
			dig = True
		ln = True
if dig == True and cap == True and (sml == True) and (ln == True):
	print('Correct')
else:
	print('Too weak')


def main():
	s = input()
	print(('Too weak', 'Correct')[len(s) > 4 and all((any(map(f, s)) for f in (str.isdigit, str.islower, str.isupper)))])
main()


from string import ascii_lowercase, ascii_uppercase
a = input()
print('Correct' if len(a) >= 5 and any((x in a for x in ascii_lowercase)) and any((x in a for x in ascii_uppercase)) and any((x in a for x in '0123456789')) else 'Too weak')


s = input()
(l, b, d) = (False, False, False)
for i in s:
	if 'a' <= i <= 'z':
		l = True
	elif 'A' <= i <= 'Z':
		b = True
	elif '0' <= i <= '9':
		d = True
print('Correct' if l and b and d and (len(s) >= 5) else 'Too weak')


a = input()
ok = 0
ok1 = 0
ok2 = 0
ok3 = 0
a = list(a)
if len(a) >= 5:
	ok = 1
for i in range(len(a)):
	if (a[i] >= 'a') & (a[i] <= 'z'):
		ok1 = 1
	if (a[i] >= 'A') & (a[i] <= 'Z'):
		ok2 = 1
	if (a[i] >= '0') & (a[i] <= '9'):
		ok3 = 1
if ok + ok1 + ok2 + ok3 == 4:
	print('Correct')
else:
	print('Too weak')


s = input()
(le, se, dig) = (False, False, False)
for i in s:
	o = ord(i)
	if 48 <= o <= 57:
		dig = True
	if 65 <= o <= 90:
		le = True
	if 97 <= o <= 122:
		se = True
	if le and se and dig:
		break
print('Correct' if le and se and dig and (len(s) >= 5) else 'Too weak')


def m(v):
	for c in v:
		if not c:
			return 0
	return 1

def ic(s):
	if len(s) < 5:
		return 0
	vc = 3 * [0]
	for c in s:
		if not vc[0] and c.islower():
			vc[0] = 1
		elif not vc[1] and c.isupper():
			vc[1] = 1
		elif not vc[2] and c.isnumeric():
			vc[2] = 1
		if m(vc):
			return 1
	return 0
s = 'Correct' if ic(input()) else 'Too weak'
print(s)


def solve():
	s = input()
	if len(s) < 5:
		return 'Too weak'
	large = False
	small = False
	digit = False
	for letter in s:
		if letter.islower():
			small = True
		if letter.isupper():
			large = True
		if letter.isnumeric():
			digit = True
	if large and small and digit:
		return 'Correct'
	return 'Too weak'
print(solve())


(a, b, c, d) = (0, 0, 0, 0)
x = input()
for i in range(len(x)):
	if x[i] >= 'A' and x[i] <= 'Z':
		a = 1
	if x[i] >= 'a' and x[i] <= 'z':
		b = 1
	if x[i] >= '0' and x[i] <= '9':
		c = 1
if a == 1 and b == 1 and (c == 1) and (len(x) >= 5):
	print('Correct')
else:
	print('Too weak')


p = list(input())

def hasupper():
	for i in p:
		if ord(i) >= 65 and ord(i) <= 90:
			return True
	return False

def haslower():
	for i in p:
		if ord(i) >= 97 and ord(i) <= 122:
			return True
	return False

def hasdigit():
	for i in p:
		if ord(i) >= 48 and ord(i) <= 57:
			return True
	return False
if len(p) < 5 or not hasupper() or (not haslower()) or (not hasdigit()):
	print('Too weak')
else:
	print('Correct')


s = input()
if len(s) >= 5:
	a = 0
	b = 0
	c = 0
	for i in s:
		if i.isdigit():
			c += 1
		elif i.isupper():
			a += 1
		elif i.islower():
			b += 1
	if a >= 1 and b >= 1 and (c >= 1):
		print('Correct')
	else:
		print('Too weak')
else:
	print('Too weak')


def weak():
	print('Too weak')
s = input()
d = False
a = False
b = False
for j in range(len(s)):
	i = s[j]
	if i >= 'a' and i <= 'z':
		a = True
	if i >= 'A' and i <= 'Z':
		b = True
	if i >= '0' and i <= '9':
		d = True
if a and b and d and (len(s) >= 5):
	print('Correct')
else:
	weak()


import string

def __main__():
	password = input('')
	lower = set(string.ascii_lowercase)
	upper = set(string.ascii_uppercase)
	number = set(string.digits)
	if len(password) < 5:
		tooWeak()
		exit(0)
	hasUpper = False
	hasLower = False
	hasNumber = False
	for char in password:
		if char in lower:
			hasLower = True
		if char in upper:
			hasUpper = True
		if char in number:
			hasNumber = True
		if hasLower and hasUpper and hasNumber:
			break
	if hasLower and hasUpper and hasNumber:
		tooStronk()
	else:
		tooWeak()

def tooWeak():
	print('Too weak')

def tooStronk():
	print('Correct')
__main__()


s = input()
a = []
a.append(len(s) >= 5)
a.append(False)
for i in s:
	if i.isupper():
		a[-1] = True
a.append(False)
for i in s:
	if i.islower():
		a[-1] = True
a.append(False)
for i in s:
	if i.isdigit():
		a[-1] = True
if all(a):
	print('Correct')
else:
	print('Too weak')


s = input()
(k, l, m) = (False, False, False)
for i in s:
	if i.isupper():
		k = True
	if i.islower():
		l = True
	if i.isdigit():
		m = True
if len(s) > 4 and k and l and m:
	print('Correct')
else:
	print('Too weak')


import re
t = input()
w = 0
while True:
	if len(t) < 5:
		w = -1
		break
	elif not re.search('[a-z]', t):
		w = -1
		break
	elif not re.search('[A-Z]', t):
		w = -1
		break
	elif not re.search('[0-9]', t):
		w = -1
		break
	else:
		w = 0
		print('Correct')
		break
if w == -1:
	print('Too weak')


s = input()
if len(s) < 5:
	print('Too weak')
else:
	a = b = c = False
	for i in range(0, 26):
		if chr(ord('A') + i) in s:
			a = True
		if chr(ord('a') + i) in s:
			b = True
		if i < 10 and chr(ord('0') + i) in s:
			c = True
	if a and b and c:
		print('Correct')
	else:
		print('Too weak')


n = input()
l = []
if len(n) >= 5:
	l.append('1')
for i in n:
	if i.isupper():
		l.append('2')
	elif i.islower():
		l.append('3')
	elif i.isdigit():
		l.append('4')
if len(set(l)) == 4:
	print('Correct')
else:
	print('Too weak')


s = input()
countup = countdown = countdigit = 0
for i in range(len(s)):
	if s[i].isupper():
		countup += 1
	elif s[i].islower():
		countdown += 1
	elif s[i].isdigit():
		countdigit += 1
if countdigit == 0 or countdown == 0 or countup == 0 or (len(s) < 5):
	print('Too weak')
else:
	print('Correct')


import sys
import re

def main():
	s = sys.stdin.read().strip()
	return ('Too weak', 'Correct')[len(s) > 4 and all((re.search(i, s) for i in ('[A-Z]', '[a-z]', '\\d')))]
print(main())


def chkupper(password):
	for i in password:
		if i.isupper():
			return True
	return False

def chklower(password):
	for i in password:
		if i.islower():
			return True
	return False

def chkdigit(password):
	for i in password:
		if i.isdigit():
			return True
	return False
password = input()
if len(password) >= 5:
	if chkupper(password):
		if chklower(password):
			if chkdigit(password):
				print('Correct')
			else:
				print('Too weak')
		else:
			print('Too weak')
	else:
		print('Too weak')
else:
	print('Too weak')


s = input()
a = False
b = False
c = False
d = False
for i in range(len(s)):
	if i >= 4:
		a = True
	if s[i] <= 'Z' and s[i] >= 'A':
		b = True
	if s[i] <= 'z' and s[i] >= 'a':
		c = True
	if s[i] >= '0' and s[i] <= '9':
		d = True
	if a and b and c and d:
		break
if a and b and c and d:
	print('Correct')
else:
	print('Too weak')


i = input()
(a, b, c) = (0, 0, 0)
l = ['!', '?', '.', ',', '_']
if len(i) < 5:
	print('Too weak')
else:
	for x in i:
		if x == ' ' or x in l:
			continue
		elif 65 <= ord(x) <= 90:
			a += 1
		elif 97 <= ord(x) <= 122:
			b += 1
		elif 48 <= ord(x) <= 57:
			c += 1
	print(['Too weak', 'Correct'][a > 0 and b > 0 and (c > 0)])


s = input()
c = 0
d = {'caps': 0, 'small': 0, 'digit': 0}
if len(s) < 5:
	print('Too weak')
else:
	f = 0
	for i in s:
		m = ord(i)
		if d['small'] == 0 and m >= 97 and (m <= 123):
			d['small'] = 1
			c += 1
		elif d['caps'] == 0 and m >= 65 and (m <= 91):
			d['caps'] = 1
			c += 1
		elif d['digit'] == 0 and m >= 48 and (m <= 57):
			d['digit'] = 1
			c += 1
		if c == 3:
			f = 1
			break
	if f == 1:
		print('Correct')
	else:
		print('Too weak')


import string
word = input()
cek = False
for i in word:
	if i.isdigit():
		cek = True
		break
if cek and (not word == word.lower()) and (not word == word.upper()) and (len(word) >= 5):
	print('Correct')
else:
	print('Too weak')


n = input()
d = []
sp = '!?.,_'
for i in n:
	if len(n) >= 5:
		d.append(1)
	if i.isupper() == True:
		d.append(2)
	if i.islower() == True:
		d.append(3)
	if i.isdigit() == True:
		d.append(4)
	if i in sp:
		d.append(5)
s = set(d)
if s == {1, 2, 3, 4} or s == {1, 2, 3, 4, 5}:
	print('Correct')
else:
	print('Too weak')


from math import *

def add_bit(n, k):
	return n | 1 << k
s = input().strip()
ans = 0
if len(s) >= 5:
	ans = add_bit(ans, 0)
for i in range(len(s)):
	if s[i] >= 'a' and s[i] <= 'z':
		ans = add_bit(ans, 1)
	if s[i] >= 'A' and s[i] <= 'Z':
		ans = add_bit(ans, 2)
	if s[i] >= '0' and s[i] <= '9':
		ans = add_bit(ans, 3)
if ans == 15:
	print('Correct')
else:
	print('Too weak')


s = input()
l = list(s)
l1 = ['!', '?', '.', ',', '_']
ch = 0
lo = 0
d = 0
up = 0
if len(l) >= 5:
	for i in range(0, len(l)):
		if l[i] >= 'A' and l[i] <= 'Z':
			lo = lo + 1
			break
	for i in range(0, len(l)):
		if l[i] >= 'a' and l[i] <= 'z':
			up = up + 1
			break
	for i in range(0, len(l)):
		if l[i].isdigit():
			d = d + 1
			break
	if up > 0 and lo > 0 and (d > 0):
		print('Correct')
	else:
		print('Too weak')
else:
	print('Too weak')


s = input()
print('Correct' if len(s) >= 5 and list(filter(str.islower, s)) and list(filter(str.isupper, s)) and list(filter(str.isdigit, s)) else 'Too weak')


a = input()
LITTLE = 0
BIG = 0
NUMBER = 0
sum = 0
for i in range(len(a)):
	if ord(a[i]) >= 97 and ord(a[i]) <= 122:
		LITTLE = 1
	elif ord(a[i]) >= 65 and ord(a[i]) <= 90:
		BIG = 1
	elif ord(a[i]) >= 49 and ord(a[i]) <= 57:
		NUMBER = 1
	sum += 1
if LITTLE == 1 and BIG == 1 and (NUMBER == 1) and (sum >= 5):
	print('Correct')
else:
	print('Too weak')


import sys
if sys.version_info[0] >= 3:
	raw_input = input
s = raw_input().rstrip()
print('Correct' if len(s) >= 5 and any((e.islower() for e in s)) and any((e.isupper() for e in s)) and any((e.isdigit() for e in s)) else 'Too weak')


x = u = l = d = 0
for c in input():
	u |= c.isupper()
	l |= c.islower()
	d |= c.isdigit()
	x += 1
print('TCooor rweecatk'[u & l & d & (x > 4)::2])


s = input()
(up, low, digit) = (False, False, False)
for ch in s:
	if ch.isdigit():
		digit = True
	elif ch.isalpha():
		if ch.isupper():
			up = True
		else:
			low = True
if len(s) >= 5 and up and low and digit:
	print('Correct')
else:
	print('Too weak')


import re
import inspect
from sys import argv, exit

def rstr():
	return input()

def rint():
	return int(input())

def rints(splitchar=' '):
	return [int(i) for i in input().split(splitchar)]

def varnames(obj, namespace=globals()):
	return [name for name in namespace if namespace[name] is obj]

def pvar(var, override=False):
	prnt(varnames(var), var)

def prnt(*args, override=False):
	if '-v' in argv or override:
		print(*args)
az = re.compile('.*[a-z].*')
AZ = re.compile('.*[A-Z].*')
zn = re.compile('.*[0-9].*')
p = rstr()
if az.match(p) and AZ.match(p) and zn.match(p) and (len(p) >= 5):
	print('Correct')
else:
	print('Too weak')


s = input()
if len(s) >= 5:
	c = 0
	sm = 0
	n = 0
	for i in s:
		if i.isupper():
			c = 1
		elif i.islower():
			sm = 1
		elif i.isnumeric():
			n = 1
	if c + sm + n >= 3:
		print('Correct')
	else:
		print('Too weak')
else:
	print('Too weak')


def check(alpha, s):
	for i in range(len(s)):
		if alpha.find(s[i]) != -1:
			return 1
	return 0
s = input()
ll = 'qewrtyuiopasdfghjklzxcvbnm'
bl = 'QWERTYUIOPASDFGHJKLZXCVBNM'
d = '0123456789'
if len(s) > 4 and check(ll, s) and check(bl, s) and check(d, s):
	print('Correct')
else:
	print('Too weak')


bot = True
import re
s = input()
print('Correct' if re.match('(?=.{5,})(?=.*\\d)(?=.*[a-z]).*[A-Z].*', s) else 'Too weak')


s = str(input())
l = []
if len(s) >= 5:
	x = any((i for i in s if i.isupper()))
	l.append(x)
	y = any((i for i in s if i.islower()))
	l.append(y)
	z = any((i for i in s if i.isdigit()))
	l.append(z)
	if False in l:
		print('Too weak')
	else:
		print('Correct')
else:
	print('Too weak')


s = input()
if s.lower() != s and s.upper() != s and (len([x for x in s if x.isdigit() == True]) != 0) and (len(s) >= 5):
	print('Correct')
else:
	print('Too weak')


a = input()
if len(a) < 5:
	print('Too weak')
	exit(0)
arr = [0] * 3
for el in a:
	if el.isupper():
		arr[0] = 1
	if el.islower():
		arr[1] = 1
	if ord(el) >= ord('0') and ord(el) <= ord('9'):
		arr[2] = 1
if not all(arr):
	print('Too weak')
else:
	print('Correct')


password = input()

def is_ok(password) -> bool:
	is_small = False
	is_big = False
	is_digit = False
	for ch in password:
		if 'A' <= ch <= 'Z':
			is_big = True
		elif 'a' <= ch <= 'z':
			is_small = True
		elif 48 <= ord(ch) <= 57:
			is_digit = True
	return len(password) >= 5 and is_small and is_big and is_digit
ok = is_ok(password)
if ok:
	print('Correct')
else:
	print('Too weak')


a = input()
up = 0
lo = 0
di = 0
sp = 0
for i in range(len(a)):
	if a[i].isupper():
		up += 1
	elif a[i].islower():
		lo += 1
	elif a[i].isdigit():
		di += 1
	else:
		sp += 1
if up > 0 and lo > 0 and (di > 0) and (len(a) > 4):
	print('Correct')
else:
	print('Too weak')


s = input()
flag = 0
if len(s) >= 5:
	for i in s:
		if ord(i) >= ord('A') and ord(i) <= ord('Z'):
			break
	else:
		flag += 1
	for i in s:
		if ord(i) >= ord('a') and ord(i) <= ord('z'):
			break
	else:
		flag += 1
	for i in s:
		if i in '0123456789':
			break
	else:
		flag += 1
else:
	flag += 1
if flag == 0:
	print('Correct')
else:
	print('Too weak')


s = input()
if len(s) >= 5 and any((str(i) in s for i in range(10))) and any((chr(i) in s for i in range(ord('a'), ord('z') + 1))) and any((chr(i) in s for i in range(ord('A'), ord('Z') + 1))):
	print('Correct')
else:
	print('Too weak')


z = input()
leng = 0
lower = 0
upper = 0
digit = 0
chara = ['!', '?', '.', ',', '_']
if len(z) >= 5:
	leng = 1
for i in z:
	if i in chara:
		charac = 1
	if i.isupper():
		upper = 1
	if i.islower():
		lower = 1
	if i.isdigit():
		digit = 1
if leng + lower + upper + digit == 4:
	print('Correct')
else:
	print('Too weak')


n = input()
(first, second, third, fourth) = (False, False, False, False)
if len(n) >= 5:
	first = True
for x in n:
	if x.isupper():
		second = True
	if x.islower():
		third = True
	if x.isdigit():
		fourth = True
if first and second and third and fourth:
	print('Correct')
else:
	print('Too weak')


def f():
	pw = input()
	if len(pw) >= 5:
		if not pw == pw.upper() and (not pw == pw.lower()):
			if any((i.isdigit() for i in pw)):
				return 'Correct'
			else:
				return 'Too weak'
	return 'Too weak'
print(f())


n = list(input())
ans = 'Too weak'
l = [False] * 3
if len(n) < 5:
	print(ans)
else:
	for i in n:
		if i.isnumeric():
			l[0] = True
		if i.islower():
			l[1] = True
		if i.isupper():
			l[2] = True
	if False in l:
		print(ans)
	else:
		print('Correct')


import re
s = input()
low = re.search('[abcdefghijklmnopqrstuvwxyz]{1}', s)
r = 'Too weak'
if not low or low.endpos <= low.pos or len(s) < 5:
	print(r)
else:
	low = re.search('[ABCDEFGHIJKLMNOPQRSTUVWXYZ]{1}', s)
	if not low or low.endpos <= low.pos:
		print(r)
	else:
		low = re.search('[\\d]{1}', s)
		if not low or low.endpos <= low.pos:
			print(r)
		else:
			print('Correct')


s = list(input())
flag = 0
if len(s) < 5:
	print('Too weak')
	flag = -1
else:
	a = 0
	b = 0
	c = 0
	for i in range(len(s)):
		if ord(s[i]) >= 65 and ord(s[i]) <= 91:
			a += 1
		if ord(s[i]) >= 97 and ord(s[i]) <= 122:
			b += 1
		if s[i] == '0' or s[i] == '1' or s[i] == '2' or (s[i] == '3') or (s[i] == '4') or (s[i] == '5') or (s[i] == '6') or (s[i] == '7') or (s[i] == '8') or (s[i] == '9'):
			c += 1
	if flag == 0 and a >= 1 and (b >= 1) and (c >= 1):
		print('Correct')
	else:
		print('Too weak')


inp = input()
length = False
upper = False
lower = False
digit = False
uppers = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
lowers = 'abcdefghijklmnopqrstuvwxyz'
digits = '0123456789'
for c in inp:
	if c in uppers:
		upper = True
	if c in lowers:
		lower = True
	if c in digits:
		digit = True
if len(inp) >= 5:
	length = True
if length and upper and lower and digit:
	print('Correct')
else:
	print('Too weak')


string = input()
small = None
capital = None
digit = None
if len(string) < 5:
	print('Too weak')
else:
	for i in string:
		if i.islower():
			small = True
		if i.isupper():
			capital = True
		if i.isnumeric():
			digit = True
		if small and capital and digit:
			print('Correct')
			break
	else:
		print('Too weak')


s = input()
if len(s) < 5:
	print('Too weak')
else:
	n = len(s)
	a = []
	b = []
	c = []
	for i in range(n):
		if s[i].isupper():
			a.append(s[i])
		elif s[i].islower():
			b.append(s[i])
		elif s[i].isnumeric():
			c.append(s[i])
	if len(a) == 0 or len(b) == 0 or len(c) == 0:
		print('Too weak')
	else:
		print('Correct')


p = input()
a = len(p) > 4
b = any((s.isdigit() for s in p))
c = any((s.islower() for s in p))
d = any((s.isupper() for s in p))
print('Correct' if all([a, b, c, d]) else 'Too weak')


(z, zz) = (input, lambda : list(map(int, z().split())))
fast = lambda : stdin.readline().strip()
zzz = lambda : [int(i) for i in fast().split()]
(szz, graph, mod, szzz) = (lambda : sorted(zz()), {}, 10 ** 9 + 7, lambda : sorted(zzz()))
from string import *
from re import *
from collections import *
from queue import *
from sys import *
from collections import *
from math import *
from heapq import *
from itertools import *
from bisect import *
from collections import Counter as cc
from math import factorial as f
from bisect import bisect as bs
from bisect import bisect_left as bsl
from itertools import accumulate as ac

def lcd(xnum1, xnum2):
	return xnum1 * xnum2 // gcd(xnum1, xnum2)

def prime(x):
	p = ceil(x ** 0.5) + 1
	for i in range(2, p):
		if x % i == 0 and x != 2 or x == 0:
			return 0
	return 1

def dfs(u, visit, graph):
	visit[u] = 1
	for i in graph[u]:
		if not visit[i]:
			dfs(i, visit, graph)
num = 1
for _ in range(num):
	ans = 0
	arr = fast()
	c = 0
	d = 0
	a = 0
	e = 0
	b = 0
	for i in arr:
		if match('[A-Z]', i):
			a = 1
		if match('[a-z]', i):
			b = 1
		if i in ['1', '2', '3', '4', '5', '6', '7', '8', '9']:
			c = 1
	if len(arr) >= 5:
		d = 1
	print('Correct' if a + b + c + d == 4 else 'Too weak')


import re
password = input()

def validate():
	a = 0
	while a < 1:
		if len(password) < 5:
			print('Too weak')
		elif re.search('[a-z]', password) is None:
			print('Too weak')
		elif re.search('[0-9]', password) is None:
			print('Too weak')
		elif re.search('[A-Z]', password) is None:
			print('Too weak')
		else:
			print('Correct')
			break
		a += 1
validate()


password = input()
A = hex(ord('A'))
Z = hex(ord('Z'))
a = hex(ord('a'))
z = hex(ord('z'))
one = hex(ord('1'))
nine = hex(ord('9'))
l = False
cap = False
lower = False
num = False
if len(password) >= 5:
	l = True
for i in range(0, len(password)):
	h = hex(ord(password[i]))
	if h <= z and h >= a:
		lower = True
	elif h <= Z and h >= A:
		cap = True
	elif h <= nine and h >= one:
		num = True
	if lower and cap and num:
		break
if l and cap and lower and num:
	print('Correct')
else:
	print('Too weak')


s = input()
(d, u, l) = (0, 0, 0)
if len(s) < 5:
	print('Too weak')
else:
	for i in s:
		if i >= '0' and i <= '9':
			d = d + 1
		elif i >= 'a' and i <= 'z':
			l = l + 1
		elif i >= 'A' and i <= 'Z':
			u = u + 1
	if d >= 1 and u >= 1 and (l >= 1):
		print('Correct')
	else:
		print('Too weak')


s = input()
if len(s) >= 5:
	if any((i.isupper() for i in s)):
		if any((i.islower() for i in s)):
			if any((i.isdigit() for i in s)):
				print('Correct')
			else:
				print('Too weak')
		else:
			print('Too weak')
	else:
		print('Too weak')
else:
	print('Too weak')


s = input()
(f1, f2, f3, f4) = (0, 0, 0, 0)
for i in range(len(s)):
	if 0 <= ord(s[i]) - ord('a') < 26:
		f1 = 1
	if len(s) >= 5:
		f2 = 1
	if 0 <= ord(s[i]) - ord('A') < 26:
		f3 = 1
	if 0 <= ord(s[i]) - ord('0') < 10:
		f4 = 1
if f1 == 1 and f2 == 1 and (f3 == 1) and (f4 == 1):
	print('Correct')
else:
	print('Too weak')


string = input()
l = 0
s = 0
d = 0
if len(string) >= 5:
	for ele in string:
		if ele.isdigit():
			d = 1
		elif ele.isupper():
			l = 1
		elif ele.islower():
			s = 1
	if s == 1 and l == 1 and (d == 1):
		print('Correct')
	else:
		print('Too weak')
else:
	print('Too weak')


s = input()
ans = 'Correct'
if len(s) < 5:
	ans = 'Too weak'
a = 0
b = 0
c = 0
for i in range(len(s)):
	if s[i].isalpha():
		if s[i].isupper():
			a += 1
		else:
			b += 1
	if s[i].isdigit():
		c += 1
if a == 0 or b == 0 or c == 0:
	ans = 'Too weak'
print(ans)