One day, the Grasshopper was jumping on the lawn and found a piece of paper with a string. Grasshopper became interested what is the minimum jump ability he should have in order to be able to reach the far end of the string, jumping only on vowels of the English alphabet. Jump ability is the maximum possible length of his jump. 

Formally, consider that at the begginning the Grasshopper is located directly in front of the leftmost character of the string. His goal is to reach the position right after the rightmost character of the string. In one jump the Grasshopper could jump to the right any distance from 1 to the value of his jump ability. [Image] The picture corresponds to the first example. 

The following letters are vowels: 'A', 'E', 'I', 'O', 'U' and 'Y'.


-----Input-----

The first line contains non-empty string consisting of capital English letters. It is guaranteed that the length of the string does not exceed 100. 


-----Output-----

Print single integer a — the minimum jump ability of the Grasshopper (in the number of symbols) that is needed to overcome the given string, jumping only on vowels.


-----Examples-----
Input
ABABBBACFEYUKOTT

Output
4
Input
AAA

Output
1

Difficulty: EASY

Solutions:
(last, res) = (-1, 0)
s = input()
for (i, c) in enumerate(s):
	if c in 'AEIOUY':
		res = max(res, i - last)
		last = i
res = max(res, len(s) - last)
print(res)


s = input()
maxi = 0
j = 0
for i in range(len(s)):
	if s[i] == 'A' or s[i] == 'E' or s[i] == 'I' or (s[i] == 'O') or (s[i] == 'U') or (s[i] == 'Y'):
		maxi = max(j, maxi)
		j = 0
	else:
		j += 1
		maxi = max(j, maxi)
print(maxi + 1)


def isVowel(ch):
	if ch == 'A' or ch == 'E' or ch == 'I' or (ch == 'O') or (ch == 'U') or (ch == 'Y'):
		return True
	return False
s = input()
last = -1
ans = 1
for i in range(0, len(s)):
	if isVowel(s[i]):
		ans = max(ans, i - last)
		last = i
ans = max(ans, len(s) - last)
print(len(s) + 1 if last == -1 else ans)


satr = input()
S = 0
koor = 1
for i in satr:
	if i == 'A' or i == 'E' or i == 'I' or (i == 'U') or (i == 'O') or (i == 'Y'):
		if koor > S:
			S = koor
		koor = 0
	koor += 1
if koor > S:
	S = koor
print(str(S))


s = 'A' + input() + 'A'
counter = 0
ans = 0
last = 0
for i in range(1, len(s)):
	if s[i] in 'AEIOUY':
		counter = i - last
		last = i
		if counter > ans:
			ans = counter
print(ans)


s = input()
last = -1

def check(a):
	if a == 'A' or a == 'E' or a == 'I' or (a == 'O') or (a == 'U') or (a == 'Y'):
		return 1
	else:
		return 0
mx = 0
for i in range(0, len(s)):
	if check(s[i]):
		k = i - last
		if k > mx:
			mx = k
		last = i
k = len(s) - last
if k > mx:
	mx = k
print(mx)


import math, sys, re, itertools, pprint, collections
(ri, rai) = (lambda : int(input()), lambda : list(map(int, input().split())))
s = input()
t = list(map(lambda x: len(x), re.split('[AEIOUY]+', s)))
print(max(t) + 1)


s = ' ' + input()
d = {'A', 'E', 'I', 'O', 'U', 'Y'}
(prev_index, max_dif) = (0, 0)
for i in range(1, len(s)):
	if s[i] in d:
		if i - prev_index > max_dif:
			max_dif = i - prev_index
		prev_index = i
	if i == len(s) - 1:
		if i - prev_index + 1 > max_dif:
			max_dif = i - prev_index + 1
print(max_dif)


s = input() + 'U'
mx = 0
last = -1
for i in range(len(s)):
	if s[i] in 'EIOUAY':
		mx = max(mx, i - last)
		last = i
print(mx)


a = input()
c = 0
z = 0
w = []
a = a + '1'
for k in range(0, len(a)):
	if a[k] == 'A' or a[k] == 'E' or a[k] == 'I' or (a[k] == 'O') or (a[k] == 'U') or (a[k] == 'Y') or (a[k] == '1'):
		b = k + 1
		z = b - z
		w.append(z)
		z = b
print(max(w))


p = list(map(lambda x: len(x), input().replace('A', ' ').replace('E', ' ').replace('I', ' ').replace('O', ' ').replace('U', ' ').replace('Y', ' ').split()))
print(max(p) + 1 if len(p) else 1)


vocales = ['A', 'E', 'I', 'O', 'U', 'Y']
palabra = str(input())
dmax = 0
dist = 0
for k in range(0, len(palabra)):
	dist += 1
	if palabra[k] in vocales:
		dmax = max(dmax, dist)
		dist = 0
	if k == len(palabra) - 1:
		dist += 1
		dmax = max(dmax, dist)
print(dmax)


t = input()
d = {'A', 'E', 'I', 'O', 'U', 'Y'}
z = 0
t1 = 0
k = 0
for i in range(len(t)):
	if t[i] in d:
		k = k + 1
		z = max(z, k)
		k = 0
	else:
		k = k + 1
		z = max(z, k)
if i == len(t) - 1 and t[i] in d:
	k += 0
else:
	k += 1
z = max(z, k)
print(z)


s = 'A' + input() + 'A'
a = [i for i in range(len(s)) if s[i] in 'AEIOUY']
print(max((a[i] - a[i - 1] for i in range(1, len(a)))))


gl = 'AEIOUY'
s = 'A' + input() + 'A'
m = 0
prev = -1
for i in range(len(s)):
	if s[i] in gl:
		m = max(m, i - prev)
		prev = i
print(m)


n = input()
v = []
for l in range(len(n)):
	v.append(n[l])
v.append('ñ')
rata = 0
cont = 0
for i in range(len(v)):
	cont += 1
	if v[i] == 'A' or v[i] == 'E' or v[i] == 'I' or (v[i] == 'O') or (v[i] == 'U') or (v[i] == 'Y') or (v[i] == 'ñ'):
		if cont > rata:
			rata = cont
		cont = 0
	else:
		pass
print(rata)


ans = 0
c = set('AOIUEY')
a = 1
for i in 'A' + input() + 'A':
	if i in c:
		ans = max(ans, a)
		a = 1
	else:
		a += 1
print(ans)


s = input()
l = []
z = len(s) + 1
ans = 1
c = 1
for i in range(len(s)):
	if s[i] == 'A' or s[i] == 'E' or s[i] == 'I' or (s[i] == 'O') or (s[i] == 'Y') or (s[i] == 'U'):
		l.append(i)
if l:
	for i in range(len(l) - 1):
		ans = max(l[i + 1] - l[i], ans)
	print(max(ans, l[0] + 1, len(s) - l[len(l) - 1]))
else:
	print(z)


str1 = 'AEYOUI'
c = 1
m = 0
for k in input() + 'A':
	if k in str1:
		if c > m:
			m = c
		c = 1
	else:
		c += 1
print(m)


string = input()
(vowels, maxJump) = ([], 0)
string = 'A' + string + 'A'
for x in range(len(string)):
	if string[x] in 'AEIOUY':
		vowels.append(x)
for x in range(len(vowels) - 1):
	jump = vowels[x + 1] - vowels[x]
	if jump > maxJump:
		maxJump = jump
print(maxJump)


paper = input()
position = []
vowels = ['A', 'E', 'I', 'O', 'U', 'Y']
for i in paper:
	if i in vowels:
		position.append(1)
	else:
		position.append(0)
jump_ability = 0
count = 0
for i in position:
	if i == 0:
		count += 1
	if i == 1:
		count += 1
		if count > jump_ability:
			jump_ability = count
		count = 0
if position[len(position) - 1] == 0:
	count += 1
if count > jump_ability:
	jump_ability = count
if len(position) == 1 and paper[0] not in vowels:
	jump_ability = 2
print(jump_ability)


import sys
import math
get_string = lambda : sys.stdin.readline().strip()
get_int_list = lambda : list(map(int, sys.stdin.readline().strip().split()))
get_int = lambda : int(sys.stdin.readline())
s = '#' + get_string()
n = len(s)
vow = {'A', 'E', 'I', 'O', 'U', 'Y'}
i = j = 0
m = 0
while j < n:
	if s[j] in vow:
		m = max(m, j - i)
		i = j
		j += 1
	else:
		j += 1
m = max(m, j - i)
print(m)


letters = list(input().strip())
jumpAbility = 0
i = 1
for letter in letters:
	if letter in ('A', 'E', 'I', 'O', 'U', 'Y'):
		i = 1
	else:
		i += 1
	if i > jumpAbility:
		jumpAbility = i
print(jumpAbility)


s = input()
lena = len(s)
Gl = ['A', 'E', 'I', 'O', 'U', 'Y']
Shag = []
i = 0
kol = 0
while i < lena:
	if s[i] in Gl:
		i += 1
		Shag += [kol]
		kol = 0
	else:
		i += 1
		kol += 1
Shag += [kol]
print(max(Shag) + 1)


s = input()
li = list(map(str, s))
listofV = ['A', 'E', 'I', 'O', 'U', 'Y']
count = 0
countli = []
l = len(li)
for i in range(l):
	if li[i] in listofV:
		count += 1
		countli.append(count)
		count = 0
	elif i == l - 1:
		count += 2
		countli.append(count)
	else:
		i += 1
		count += 1
print(max(countli))


s = input()
d = ['A', 'E', 'I', 'O', 'U', 'Y']
g = -1
c = 1
for i in s:
	if i in d:
		c = 1
	else:
		c += 1
		g = max(g, c)
g = max(g, c)
print(g)


s = input()
count1 = 0
s = 'A' + s + 'A'
list1 = []
for i in range(len(s)):
	if s[i] in ['A', 'E', 'I', 'O', 'U', 'Y']:
		count2 = i
		list1.append(count2 - count1)
		count1 = count2
print(max(list1))


from sys import stdin

def main():
	s = stdin_get_string_from_line()
	cur_num = 1
	max_num = 1
	for x in s:
		if x in ['A', 'E', 'I', 'O', 'U', 'Y']:
			if max_num < cur_num:
				max_num = cur_num
			cur_num = 1
		else:
			cur_num += 1
	if max_num < cur_num:
		max_num = cur_num
	print(max_num)
	return

def stdin_get_ints_from_line():
	return (int(x) for x in stdin.readline().strip().split(' '))

def stdin_get_ints_list_from_line():
	return list((int(x) for x in stdin.readline().strip().split(' ')))

def stdin_get_string_from_line():
	return stdin.readline().strip()
main()


x = input()
q = {'A', 'E', 'I', 'Y', 'O', 'U'}
k = 0
y = 0
p = -1
for i in x:
	if i in q:
		w = p
		p = y
		if p - w > k:
			k = p - w
	y += 1
if len(x) - p > k:
	k = len(x) - p
print(k)


def main():
	from sys import stdin, stdout
	s = stdin.readline().lower()
	maxjump = 0
	j = 1
	for i in s:
		if i == 'a' or i == 'e' or i == 'i' or (i == 'o') or (i == 'u') or (i == 'y') or (i == '\n'):
			maxjump = max(maxjump, j)
			j = 1
		else:
			j += 1
	stdout.write(str(maxjump))
main()


g = 'AEIOUY'
m = 0
p = 0
f = list(str(input()))
for i in range(len(f)):
	if g.count(f[i]) == 0:
		p += 1
	else:
		m = max(m, p + 1)
		p = 0
m = max(m, p + 1)
print(m)


s = input()
s = s + 'A'
init = -1
ans = 0
for i in range(len(s)):
	if s[i] in 'AEIOUY':
		ans = max(ans, i - init)
		init = i
print(ans)


def hopper(s):
	vals = [0]
	vowels = 'AEIOUY'
	for (i, n) in enumerate(s):
		if n in vowels:
			vals.append(i + 1)
	vals.append(len(s) + 1)
	ans = 0
	for i in range(1, len(vals)):
		val = vals[i] - vals[i - 1]
		ans = max(ans, val)
	return ans
s = input()
print(hopper(s))


lis = ['A', 'E', 'I', 'O', 'U', 'Y']
s = 'A' + input() + 'A'
c = []
for i in range(len(s)):
	if s[i] in lis:
		for j in range(i + 1, len(s)):
			if s[j] in lis:
				c.append(j - i)
				break
print(max(c))


z = input()
v = 'AEIOUY'
l = 1
m_l = 0
if len(z) < 2:
	if z in v:
		print(1)
	else:
		print(2)
else:
	for i in range(len(z)):
		if z[i] in v:
			if l > m_l:
				m_l = l
			l = 0
		l = l + 1
	if l > m_l:
		m_l = l
	print(m_l)


s = input()
cnt = jump = 0
vowels = ['A', 'E', 'I', 'O', 'U', 'Y']
for i in range(len(s)):
	if s[i] not in vowels:
		cnt += 1
		if cnt > jump:
			jump = cnt
	else:
		cnt = 0
print(jump + 1)


y = 'AEIOUY'
N = input()
t = 0
r = -1
for i in range(len(N)):
	if N[i] in y:
		t = max(t, i - r)
		r = i
print(max(t, len(N) - r))


__author__ = 'Alexander'
s = input()
k = 0
last = 0
p = [0]
for (i, c) in enumerate(s):
	if c in ['A', 'E', 'I', 'O', 'U', 'Y']:
		p.append(i + 1)
p.append(len(s) + 1)
i = 0
n = len(p)
while i < n - 1:
	d = p[i + 1] - p[i]
	if d > k:
		k = d
	i += 1
print(k)


s = input()
s += 'A'
ans = 0
now = -1
for (i, c) in enumerate(s):
	if c == 'A' or c == 'E' or c == 'I' or (c == 'O') or (c == 'U') or (c == 'Y'):
		ans = max(ans, i - now)
		now = i
print(ans)


s = input()
s1 = [i for i in range(len(s)) if s[i] == 'A' or s[i] == 'E' or s[i] == 'I' or (s[i] == 'O') or (s[i] == 'U') or (s[i] == 'Y')]
d = 0
for i in range(len(s1) - 1):
	if s1[i + 1] - s1[i] > d:
		d = s1[i + 1] - s1[i]
if d == 0 and len(s1) != 0:
	print(max(s1[0] + 1, len(s) - s1[-1]))
elif len(s1) == 0:
	print(len(s) + 1)
else:
	d = max(d, len(s) - s1[-1], s1[0] + 1)
	print(d)


vowels = 'AEIOUY'
string = input() + 'A'
max = temp = 0
for i in range(len(string)):
	temp += 1
	if string[i] in vowels:
		if max < temp:
			max = temp
		temp = 0
print(max)


import re
print(str(max((len(x) for x in re.split('[AEIOUY]+', input()))) + 1))


val = input()
ans = 0
curr_val = 0
for i in val:
	if i in ('A', 'E', 'I', 'O', 'U', 'Y'):
		ans = max(ans, curr_val)
		curr_val = 0
	else:
		curr_val += 1
ans = max(ans, curr_val)
print(ans + 1)


st = input()
vow = ['A', 'E', 'I', 'O', 'U', 'Y']
mn = 1
cur = 1
for i in range(len(st)):
	if st[i] in vow:
		mn = max(mn, cur)
		cur = 0
	cur += 1
print(max(mn, cur))


char = ['A']
char += list(input())
char.append('A')
val = len(char)
list2 = ['A', 'E', 'I', 'O', 'U', 'Y']
max = 0
val1 = 0
for i in range(0, val):
	if char[i] in list2:
		for j in range(i + 1, val):
			if char[j] in list2:
				val1 = j - i
				i = j
				break
	if max < val1:
		max = val1
print(max)


s = input()
a = ['A', 'E', 'I', 'O', 'U', 'Y']
j = 1
c = 1
for i in s:
	if i not in a:
		c += 1
		j = max(j, c)
	else:
		c = 1
print(j)


word = input().strip()
ind = []
for i in range(len(word)):
	if word[i] in ('A', 'E', 'I', 'O', 'U', 'Y'):
		ind.append(i)
ind.append(len(word))
jump = []
jump.append(ind[0] + 1)
for i in range(len(ind) - 1):
	jump.append(ind[i + 1] - ind[i])
print(max(jump))


s = input() + 'A'
vowels = 'AEIOUY'
c = 1
m = 1
pp = False
for k in s:
	if k in vowels:
		pp = True
		m = max(m, c)
		c = 1
	else:
		c += 1
if pp is True:
	print(m)
else:
	print(len(s))


s = list(input())
glas = 'AEIOUY'
cnt = 0
ans = 0
for i in s:
	if i not in glas:
		cnt += 1
	else:
		ans = max(ans, cnt)
		cnt = 0
print(max(cnt, ans) + 1)


vowels = {'A', 'E', 'I', 'O', 'U', 'Y'}
word = 'A' + input() + 'A'
diffs = []
for (i, c) in enumerate(word):
	if c in vowels:
		diffs.append(i + 1)
print(max([diffs[i] - diffs[i - 1] for i in range(1, len(diffs))]))


(vowels, prev_vowel, s, min_d) = ('AEIOUY', -1, input(), 0)
for i in range(len(s)):
	if s[i] in vowels:
		min_d = max(min_d, i - prev_vowel)
		prev_vowel = i
print(max(min_d, len(s) - prev_vowel))


s = input()
curr = 0
max_jump = 0
for c in s:
	curr += 1
	max_jump = max(curr, max_jump)
	if c == 'A' or c == 'E' or c == 'I' or (c == 'O') or (c == 'U') or (c == 'Y'):
		curr = 0
curr += 1
max_jump = max(curr, max_jump)
print(max_jump)


s = input()
l = ['A', 'E', 'O', 'U', 'I', 'Y']
for i in range(6):
	s = s.replace(l[i], '$')
s = s.split('$')
if len(s) == 1:
	print([len(s[0]) + 1, '1'][s in l])
else:
	print(len(max(s, key=len)) + 1)


a = input()
vowels = {'A', 'E', 'I', 'O', 'U', 'Y'}
maxs = 1
count = 1
for x in a + 'A':
	if x not in vowels:
		count += 1
	else:
		if count > maxs:
			maxs = count
		count = 1
print(maxs)


str = input()
Mgb = 0
Mxgb = -1
for (i, x) in enumerate(str + 'A'):
	if x in 'AEIOUY':
		Mgb = max(Mgb, i - Mxgb)
		Mxgb = i
print(Mgb)


from re import split
s = input().strip()
print(max((len(w) for w in split('[aeiouyAEIOUY]', s))) + 1)


st = input()
vowels = ['A', 'E', 'I', 'O', 'U', 'Y']
vowelpos = [-1]
for i in range(len(st)):
	if st[i] in vowels:
		vowelpos.append(i)
vowelpos.append(len(st))
answer = 0
for i in range(1, len(vowelpos)):
	if vowelpos[i] - vowelpos[i - 1] > answer:
		answer = vowelpos[i] - vowelpos[i - 1]
print(answer)


a = input()
b = ['A', 'E', 'I', 'O', 'U', 'Y']
c = []
c.append(-1)
for i in range(len(a)):
	if a[i] in b:
		c.append(i)
c.append(len(a))
ans = 0
for i in range(len(c) - 1):
	ans = max(ans, c[i + 1] - c[i])
print(ans)


s = input()
l = [0]
for i in range(len(s)):
	if s[i] == 'A' or s[i] == 'E' or s[i] == 'I' or (s[i] == 'O') or (s[i] == 'U') or (s[i] == 'Y'):
		l.append(i + 1)
l.append(len(s) + 1)
l2 = []
for i in range(len(l) - 1):
	l2.append(l[i + 1] - l[i])
print(max(l2))


s = input()
x = ['A', 'E', 'I', 'O', 'U', 'Y']
j = 0
k = 0
for i in range(len(s)):
	if k > j:
		j = k
	if s[i] in x:
		k = 0
	if s[i] not in x:
		k = k + 1
if k > j:
	j = k
print(j + 1)


string = input() + 'A'
pre = -1
ans = 0
for (index, char) in zip(range(len(string)), string):
	if char in 'AEIOUY':
		ans = max(ans, index - pre)
		pre = index
print(ans)


array = list(input()) + ['0']
vowels = ['A', 'E', 'I', 'O', 'U', 'Y']
jump = 0
total = []
for i in array:
	if i in vowels or i == '0':
		jump += 1
		total.append(jump)
		jump = 0
	else:
		jump += 1
print(max(total))


a = list(input())
a.append('A')
a.insert(0, 'A')
s = 1
e = 1
b = ['A', 'E', 'I', 'O', 'U', 'Y']
for i in range(0, len(a)):
	if a[i] in b:
		s = max(s, e)
		e = 1
	else:
		e += 1
print(s)


s = str(input())
last = -1
jump = 0
glas = ['A', 'E', 'I', 'O', 'U', 'Y']
for i in range(len(s)):
	if s[i] in glas:
		jump = max(i - last, jump)
		last = i
jump = max(jump, len(s) - last)
print(jump)


z = input().upper()
d = []
g = []
q = 'AOIEYU'
for i in range(len(z)):
	if z[i] in q:
		if g == []:
			d.append(i + 1)
			g.append(i)
		else:
			d.append(abs(g[-1] - i))
			g.append(i)
if g == []:
	print(len(z) + 1)
else:
	d.append(len(z) - g[-1])
	print(max(d))


s = 'A' + input() + 'A'
ans = last = 0
for i in range(len(s)):
	if s[i] in 'AEIOUY':
		ans = max(ans, i - last)
		last = i
print(ans)


s = input()
v = ['A', 'E', 'I', 'O', 'U', 'Y']
cur = -1
ans = 0
for i in range(len(s)):
	if s[i] in v:
		ans = max(i - cur, ans)
		cur = i
ans = max(len(s) - cur, ans)
print(ans)


s = input()
v = ['A', 'E', 'I', 'O', 'U', 'Y']
p = [0]
for i in range(1, len(s) + 1):
	if s[i - 1] in v:
		p.append(i)
p.append(len(s) + 1)
print(max([p[i] - p[i - 1] for i in range(1, len(p))]))


s = 0
k = 0
i = 0
for j in input() + 'A':
	i += 1
	if j in 'AEIOUY':
		k = max(k, i - s)
		s = i
print(k)


s = input()
l = -1
res = 0
for i in range(0, len(s)):
	if s[i] in ('A', 'E', 'I', 'O', 'U', 'Y'):
		res = max(res, i - l)
		l = i
res = max(res, len(s) - l)
print(res)


vowel = ['A', 'I', 'U', 'E', 'O', 'Y']
s = str(input())
ans = 0
temp = -1
if any((x in s for x in vowel)):
	for i in range(len(s)):
		if s[i] in vowel:
			ans = max(ans, abs(temp - i))
			temp = i
	ans = max(ans, abs(len(s) - temp))
	print(ans)
else:
	print(len(s) + 1)


lI = -1
cur = 0
s = {'A', 'E', 'I', 'O', 'U', 'Y'}
S = input()
for x in range(len(S)):
	if S[x] in s:
		if lI == -1:
			cur = x + 1
			lI = x
		else:
			cur = max(cur, x - lI)
			lI = x
if lI != -1:
	cur = max(cur, len(S) - lI)
elif lI == -1:
	cur = len(S) + 1
print(cur)


s = input()
p = [0] + [i + 1 for (i, c) in enumerate(s) if c in 'AEOUIY'] + [len(s) + 1]
print(max((p[i] - p[i - 1] for i in range(1, len(p)))))


letters = ['A', 'E', 'I', 'O', 'U', 'Y']
diffs = []
string_input = str(input())
diff = 1
for symbol in string_input:
	if symbol in letters:
		diffs.append(diff)
		diff = 1
	else:
		diff += 1
if diff > 1:
	diffs.append(diff)
print(max(diffs))


s = input()
s += 'A'
m = 0
k = 1
p = 0
for i in s:
	if i in 'AEIOUY':
		m = max(m, k - p)
		p = k
	k += 1
print(m)


def solution(s):
	vowel = 'AEIOUY'
	max_count = 0
	count = 0
	for l in s:
		if l in vowel:
			if count > max_count:
				max_count = count
			count = 0
		else:
			count += 1
	print(max(max_count, count) + 1)
s = input()
solution(s)


word = 'O' + input() + 'O'
positions = [i for i in range(len(word)) if word[i] in 'AEIOUY']
jumps = [positions[i] - positions[i - 1] for i in range(1, len(positions))]
print(max(jumps))


s = input()
for v in ['a', 'e', 'i', 'o', 'u', 'y']:
	s = s.replace(v.upper(), ' ')
print(len(max(s.split() + [''], key=len)) + 1)


c = ['A', 'E', 'I', 'O', 'U', 'Y']
s = input()
(j, k) = (-1, 1)
t = 0
for i in range(len(s)):
	if s[i] in c:
		k = max(k, i - j)
		j = i
		t = 1
k = max(k, len(s) - j)
print(k)


s = input()
i = -1
ans = 0
for j in range(len(s)):
	if s[j] in 'AEIOUY':
		ans = max(ans, j - i)
		i = j
ans = max(ans, len(s) - i)
print(ans)


x = input()
s = i = 0
for j in x:
	if j in 'AIOUYE':
		i = 0
	else:
		i += 1
		s = max(s, i)
print(s + 1)


s = input()
indices = [i for (i, x) in enumerate(s) if x == 'A' or x == 'E' or x == 'I' or (x == 'O') or (x == 'U') or (x == 'Y')]
if len(indices) == 1:
	print(max(indices[0] + 1, len(s) - indices[0]))
elif len(indices) == 0:
	print(len(s) + 1)
else:
	m = []
	for i in range(len(indices) - 1):
		m.append(indices[i + 1] - indices[i])
	m.append(len(s) - indices[len(indices) - 1])
	m.append(indices[0] + 1)
	print(max(m))


s = input()
s = s + 'A'
m = 0
cur = -1
while cur != len(s) - 1:
	i = cur + 1
	while s[i] not in ['A', 'E', 'Y', 'U', 'I', 'O']:
		i += 1
	m = max(m, i - cur)
	cur = i
print(m)


ch = input()
vowel = 'AEIOUY'
c = 0
p = 0
for i in ch:
	if i in vowel:
		c = 0
	else:
		c += 1
	p = max(p, c)
print(p + 1)


vowels = ['I', 'O', 'U', 'A', 'E', 'Y']

def max_distance_of_vowels(s):
	maximum = 0
	current = 0
	for (i, v) in enumerate(s):
		if v not in vowels:
			current += 1
			continue
		current += 1
		if current > maximum:
			maximum = current
		current = 0
	current += 1
	if current > maximum:
		maximum = current
	return maximum
string = input()
print(max_distance_of_vowels(string))


st = 'AEIOUY'
max = 0
count = 1
inp = input()
for letter in inp:
	if letter in st:
		count = 1
	else:
		count += 1
	if max < count:
		max = count
print(max)


s = input()
i = 0
distance = []
last = -1
for (i, elem) in enumerate(s):
	if elem == 'A' or elem == 'E' or elem == 'I' or (elem == 'O') or (elem == 'U') or (elem == 'Y'):
		distance.append(i - last)
		last = i
distance.append(len(s) - last)
print(max(distance))


str = input()
A = ['A', 'E', 'I', 'O', 'U', 'Y']
K = []
leng = len(str)
if leng == 0:
	print(1)
	exit(0)
for i in range(leng):
	if str[i] in A:
		K.append(i)
K.append(leng)
lk = len(K)
if lk == 1:
	print(K[0] + 1)
	exit(0)
minn = 1
for i in range(1, lk):
	diff = K[i] - K[i - 1]
	if diff > minn:
		minn = diff
if K[0] + 1 > minn:
	minn = K[0] + 1
print(minn)


s = input() + 'A'
v = 'AEOIUY'
prev = -1
i = 0
maxj = 1
for c in s:
	if c in v:
		maxj = max(maxj, i - prev)
		prev = i
	i += 1
print(maxj)


def is_vowel(c):
	return c in ('A', 'E', 'I', 'O', 'U', 'Y')
string = 'A' + input().strip() + 'A'
jumps = []
last_vowel = 0
for i in range(1, len(string)):
	char = string[i]
	if is_vowel(char):
		jump = i - last_vowel
		jumps.append(jump)
		last_vowel = i
jump_ability = max(jumps)
print(jump_ability)


def main():
	a = input()
	list1 = 'AEIOUY'
	a = 'A' + a + 'A'
	b = 1
	list2 = []
	for i in range(1, len(a)):
		if a[i] in list1:
			list2.append(i)
	for i in range(len(list2) - 1, 0, -1):
		list2[i] = list2[i] - list2[i - 1]
	return max(list2)
print(main())


s = input()
sag = 0
mas_dop = ['A', 'E', 'I', 'O', 'U', 'Y']
max_dl = 1
for i in range(0, len(s)):
	if s[i] not in mas_dop:
		ip = i
		while ip < len(s) and s[ip] not in mas_dop:
			sag += 1
			ip += 1
		if sag >= max_dl:
			max_dl = sag + 1
		sag = 0
print(max_dl)


prev = -1
mx = -1
n = list(input())
for i in range(len(n)):
	if n[i] == 'A' or n[i] == 'I' or n[i] == 'E' or (n[i] == 'O') or (n[i] == 'U') or (n[i] == 'Y'):
		mx = max(mx, i - prev)
		prev = i
mx = max(mx, len(n) - prev)
print(mx)


s = set(list('EYUIOA'))
f = input()
ans = 0
ind = 0
last = -1
while ind != len(f):
	if f[ind] in s:
		ans = max(ans, ind - last)
		last = ind
	ind += 1
ans = max(ans, ind - last)
print(ans)


(x, y, z, h) = (input(), 0, 'AEIOUY', [])
for a in x:
	if a in z:
		y += 1
		h.append(y)
		y = 0
	else:
		y += 1
h.append(y + 1)
print(max(h))


arr = list(input())
vowels = ['A', 'E', 'I', 'O', 'U', 'Y']
count = 0
jump = [0]
for x in arr:
	if x not in vowels:
		count += 1
	else:
		count += 1
		jump.append(count)
		count = 0
count += 1
jump.append(count)
print(max(jump))


string = input()
vowel = 'AEIOUY'
max_step = 0
place = 0
string = '0' + string + '1'
for index in range(1, len(string)):
	if string[index] in vowel or string[index] == '1':
		step = index - place
		place = index
		max_step = max(max_step, step)
print(max_step)


s = input()
l = 'AEIOUY'
n = len(s)
b = [-1]
m = 0
if n == 1:
	if s[0] in l:
		print(1)
	else:
		print(2)
else:
	for i in range(n):
		if s[i] in l:
			b.append(i)
			a = n
	b.append(n)
	for i in range(1, len(b)):
		m = max(m, b[i] - b[i - 1])
	if len(b) != 0:
		print(m)
	else:
		print(n + 1)


ch = input()
voy = 'AEYUIO'
d = 1
i = 0
while i < len(ch):
	if ch[i] in voy:
		i = i + 1
	else:
		j = 1
		while ch[i] not in voy:
			j = j + 1
			i = i + 1
			if i == len(ch):
				break
		if d < j:
			d = j
		if i == len(ch):
			break
print(d)


s = input()
letter = ['A', 'E', 'I', 'O', 'U', 'Y']
max = 1
count = 1
for x in s:
	if x in letter:
		if count > max:
			max = count
		count = 1
	else:
		count += 1
if count > max:
	print(count)
else:
	print(max)


si = input()
l = 1
rez = 0
for e in si:
	rez = max(rez, l)
	if e in ['A', 'E', 'I', 'O', 'U', 'Y']:
		l = 0
	l += 1
print(max(rez, l))


S = input()
if S[0] != 'A' and S[0] != 'E' and (S[0] != 'I') and (S[0] != 'O') and (S[0] != 'U') and (S[0] != 'Y'):
	k = 2
else:
	k = 1
l = [k]
for i in range(len(S) - 1):
	if S[i + 1] != 'A' and S[i + 1] != 'E' and (S[i + 1] != 'I') and (S[i + 1] != 'O') and (S[i + 1] != 'U') and (S[i + 1] != 'Y'):
		k = k + 1
		l.append(k)
	else:
		k = 1
print(max(l))


s = input()
c = ''
for i in s:
	if i == 'A' or i == 'E' or i == 'I' or (i == 'O') or (i == 'U') or (i == 'Y'):
		c += 'A'
	else:
		c += i
r = 0
c += 'A'
while True:
	ind = c.find('A')
	if ind == -1:
		break
	r = max(r, ind + 1)
	c = c[ind + 1:]
print(r)


s = input()
a = []
a.append(0)
for i in range(len(s)):
	if s[i] in ['A', 'E', 'I', 'O', 'U', 'Y']:
		a.append(i + 1)
a.append(len(s) + 1)
ans = 0
j = 1
while j < len(a):
	ans = max(ans, a[j] - a[j - 1])
	j += 1
print(ans)


import os
import sys
from io import BytesIO, IOBase
import math
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')
s = input()
l = list()
v = 'AEIOYU'
l.append(0)
for i in range(len(s)):
	if s[i] in v:
		l.append(i + 1)
l.append(len(s) + 1)
ans = 1
for i in range(1, len(l)):
	ans = max(ans, l[i] - l[i - 1])
print(ans)


v = ['A', 'E', 'I', 'O', 'U', 'Y']
a = input()
p = []
s = 0
l = 0
for k in range(len(a)):
	if a[k] in v:
		p.append(k - s)
		l += 1
		s = k
p.append(len(a) - s)
if len(p) >= 1:
	p[0] += 1
if l == 0:
	print(len(a) + 1)
else:
	print(max(p))


import itertools
print(1 + max([len(list(g)) for (_, g) in filter(lambda i: i[0], itertools.groupby(map(lambda x: x not in 'AEIOUY', input())))], default=0))


a = input()
count = max = 1
for i in range(len(a)):
	if a[i] not in ['A', 'E', 'I', 'O', 'U', 'Y'] and i == len(a) - 1:
		count += 1
		if max <= count:
			max = count
	elif a[i] not in ['A', 'E', 'I', 'O', 'U', 'Y'] and i != len(a) - 1:
		count += 1
	else:
		if max <= count:
			max = count
		count = 1
print(max)


s = input()
ss = list(map(lambda x, y: (x in 'AEIOUY', y), s, range(len(s))))
ss = list(filter(lambda x: x[0], ss))
ss = list(map(lambda x: x[1], ss))
ss0 = [-1]
ss0.extend(ss)
ss.append(len(s))
print(max(map(lambda x, y: x - y, ss, ss0)))


s = input()
if not ('A' in s or 'E' in s or 'I' in s or ('O' in s) or ('U' in s) or ('Y' in s)):
	print(len(s) + 1)
else:
	m = 0
	t = 0
	for i in range(len(s)):
		t = t + 1
		if s[i] == 'A' or s[i] == 'E' or s[i] == 'I' or (s[i] == 'O') or (s[i] == 'U') or (s[i] == 'Y'):
			m = max(t, m)
			t = 0
	m = max(t + 1, m)
	print(m)


glas = ['A', 'E', 'I', 'O', 'U', 'Y']
s = input().strip()
s = 'A' + s + 'A'
n = len(s)
left = -1
right = n + 3
while right - left > 1:
	mid = (left + right) // 2
	dp = [None] * n
	dp[0] = True
	for i in range(1, n):
		for j in range(max(0, i - mid), i):
			if s[j] in glas:
				dp[i] = dp[i] or dp[j]
	if dp[-1]:
		right = mid
	else:
		left = mid
print(right)


string = input()
vowels = 'AEIOUY'
is_vowel = False
counter = 1
store = 0
for x in string:
	if x in vowels:
		if counter > store:
			store = counter
			counter = 1
		else:
			counter = 1
	else:
		counter = counter + 1
if counter > store:
	store = counter
print(store)


s = input()
Glas = ['A', 'E', 'I', 'O', 'U', 'Y']
i = 1
m = 0
l = 1
s = s + 'l'
for i in range(len(s) - 1):
	if s[i] not in Glas:
		l += 1
	if l > m:
		m = l
	if s[i] in Glas:
		l = 1
print(m)


ch = ' ' + input() + ' '
vo = 'AEIOUY'
pos = 0
c = 0
for i in range(len(ch)):
	if ch[i] in vo:
		if i - pos > c:
			c = i - pos
		pos = i
if len(ch) - 1 - pos > c:
	c = len(ch) - 1 - pos
print(c)


def f(c):
	return c == 'A' or c == 'E' or c == 'I' or (c == 'O') or (c == 'U') or (c == 'Y')
s = input().split()[0]
a = [0] * len(s)
for i in range(len(s)):
	a[i] = (s[i], i + 1)
a = [elem for (letter, elem) in a if f(letter)]
b = [0] * len(a)
if len(a) != 0:
	b[0] = a[0]
	for i in range(1, len(a)):
		b[i] = a[i] - a[i - 1]
	b.append(len(s) + 1 - a[len(a) - 1])
	print(max(b))
else:
	print(len(s) + 1)


s = input()
a = [-1]
for i in range(len(s)):
	if s[i] in ['A', 'E', 'I', 'O', 'U', 'Y']:
		a += [i]
a += [len(s)]
ans = -1
for i in range(1, len(a)):
	ans = max(ans, a[i] - a[i - 1])
print(ans)


a = input()
g = 'AEOIUY'
p = 1
pm = 0
for i in a:
	if i not in g:
		p += 1
	else:
		if pm < p:
			pm = p
		p = 1
if pm < p:
	pm = p
print(pm)


s = list('A' + input() + 'A')
a = 0
javab = 0
for i in range(len(s)):
	if s[i] == 'A' or s[i] == 'E' or s[i] == 'O' or (s[i] == 'U') or (s[i] == 'Y') or (s[i] == 'I'):
		if javab < i - a:
			javab = i - a
		a = i
print(javab)


S = input()
Voyelles = ['A', 'E', 'I', 'O', 'U', 'Y']
C = 0
cmpt = []
k = 0
if len(S) == 1:
	if S[0] in Voyelles:
		C = 1
	else:
		C = 2
else:
	if S[-1] not in Voyelles:
		S = S + 'A'
	if S[0] not in Voyelles:
		S = 'A' + S
	for i in range(len(S)):
		if S[i] in Voyelles:
			cmpt.append(i + 1)
	for i in range(len(cmpt) - 1):
		v = cmpt[i + 1] - cmpt[i]
		if C < v:
			C = v
	for i in S:
		if i in Voyelles:
			k = k + 1
	if k == len(S):
		C = 1
print(C)


p = -1
r = 0
for c in 'A' + input() + 'A':
	p += 1
	if c in 'AEIOUY':
		r = max(r, p)
		p = 0
print(r)


a = str(input())
a = a + 'A'
vowels = ['A', 'E', 'I', 'O', 'U', 'Y']
lar = jump = 0
for i in range(len(a)):
	if a[i] in vowels:
		jump += 1
		if jump > lar:
			lar = jump
		jump = 0
	else:
		jump += 1
print(lar)


a = input().strip()
a += 'A'
glas = {'A', 'E', 'I', 'O', 'U', 'Y'}
max_value = 0
prev_indx = -1
n = len(a)
for i in range(n):
	if a[i] not in glas:
		continue
	if i - prev_indx > max_value:
		max_value = i - prev_indx
	prev_indx = i
print(max_value)


a = input()
n = len(a)
yo = 'AEIOUY'
mini = 0
for i in range(n):
	if a[i] in yo:
		prev = i
		mini = i + 1
		break
count = 0
for i in range(i, n):
	if a[i] in yo:
		count += 1
		if i - prev > mini:
			mini = i - prev
		prev = i
if mini == 0:
	if count == 0:
		print(n + 1)
	elif count == 1:
		print(max(prev + 1, n - prev))
else:
	print(max(mini, n - prev))


g = ['A', 'E', 'I', 'O', 'U', 'Y']
s = input()
ans = 0
(i, j) = (0, 0)
while i < len(s):
	if s[i] in g:
		i += 1
		j = 0
	else:
		j += 1
		i += 1
	ans = max(ans, j)
print(ans + 1)


string = input()
vowel = ['A', 'E', 'I', 'O', 'U', 'Y']
find = []
in_str = 0
for i in range(1, len(string) + 1):
	if string[i - 1] in vowel:
		in_str += 1
		find.append(in_str)
		in_str = 0
	else:
		in_str += 1
find.append(in_str + 1)
print(max(find))


string = input()
distance = 0
counter = 1
for i in range(len(string)):
	element = string[i]
	if element not in ['A', 'E', 'I', 'O', 'U', 'Y']:
		counter += 1
	else:
		distance = max(distance, counter)
		counter = 1
print(max(distance, counter))


S = input()
ma = 1
k = 1
for i in range(len(S)):
	if S[i] == 'A' or S[i] == 'E' or S[i] == 'I' or (S[i] == 'O') or (S[i] == 'U') or (S[i] == 'Y'):
		if ma < k:
			ma = k
		k = 1
	else:
		k = k + 1
if ma < k:
	ma = k
print(ma)


s = input()
s = s + 'A'
jump_max = 1
(a, b) = (0, 0)
n = len(s)
for i in range(n):
	if s[i] in ('A', 'E', 'I', 'O', 'U', 'Y'):
		(a, b) = (b, i + 1)
		jump_max = max(jump_max, b - a)
print(jump_max)


import re
I = lambda : map(int, input().split())
s = input()
l = re.findall('([^EAUIOY]+)', s)
print(1 if len(l) == 0 else max([len(x) + 1 for x in l]))


kuzik = ['A']
kuzik += list(input())
kuzik.append('A')
jump = 0
after = 0
glas = ['A', 'E', 'I', 'O', 'U', 'Y']
for i in range(len(kuzik)):
	for c in glas:
		if kuzik[i] == c:
			if jump < i - after:
				jump = i - after
			after = i
print(jump)


the_string = input()
vowels = 'AEIOUY'
hop_point = [-1] + [i for i in range(len(the_string)) if the_string[i] in vowels] + [len(the_string)]
min_jump = 0
for j in range(1, len(hop_point)):
	min_jump = max(min_jump, hop_point[j] - hop_point[j - 1])
print(min_jump)


S = ['A', 'E', 'I', 'O', 'U', 'Y']
s = input()
s = 'A' + s + 'A'
ans = 0
for i in range(len(s)):
	if s[i] not in S:
		continue
	for j in range(i + 1, len(s)):
		if s[j] in S:
			ans = max(ans, j - i)
			break
print(ans)


s = input()
n = len(s)
alph = {'A', 'O', 'E', 'U', 'Y', 'I'}
last_ind = 0
while last_ind < n:
	if last_ind >= n or s[last_ind] in alph:
		break
	last_ind += 1
if last_ind == n:
	print(n + 1)
else:
	ans = last_ind + 1
	for i in range(last_ind + 1, n):
		if s[i] in alph:
			ans = max(ans, i - last_ind)
			last_ind = i
	if s[-1] not in alph:
		print(max(ans, n - last_ind))
	else:
		print(ans)


s = 'A' + input() + 'A'
vowels = 'AEIOUY'
vowels = vowels + vowels.lower()
ma = 0
tmp = 1
for i in s:
	if i in vowels:
		if tmp > ma:
			ma = tmp
		tmp = 1
	else:
		tmp += 1
print(ma)


s = input()
import re
pattern = re.compile('[AEIOUY]')
idxs = [-1] + [m.start() for m in pattern.finditer(s)] + [len(s)]
max_jump = 1
for (idx, val) in enumerate(idxs):
	if idx != len(idxs) - 1:
		max_jump = max(abs(idxs[idx + 1] - val), max_jump)
print(max_jump)


_ = ['A', 'E', 'I', 'O', 'U', 'Y']
__ = input()
___ = 1
____ = 1
for _i_ in range(len(__)):
	if __[_i_] not in _:
		___ += 1
	else:
		___ = 1
	if ___ > ____:
		____ = ___
print(____)


a = input()
c = 1
k = 1
for i in range(len(a)):
	if a[i] != 'A' and a[i] != 'E' and (a[i] != 'I') and (a[i] != 'O') and (a[i] != 'U') and (a[i] != 'Y'):
		c += 1
	elif k < c:
		k = c
		c = 1
	else:
		c = 1
print(max(k, c))


s = input()
A = []
max = 1
D = []
A.append(0)
for i in range(0, len(s)):
	if s[i] == 'A' or s[i] == 'E' or s[i] == 'O' or (s[i] == 'I') or (s[i] == 'U') or (s[i] == 'Y'):
		A.append(i)
A.append(len(s))
for i in range(1, len(A)):
	D.append(A[i] - A[i - 1])
D[0] = D[0] + 1
D.sort(reverse=True)
if len(D) == 0:
	print(len(s) + 1)
else:
	print(D[0])


string = input()
maximum_length = 1
length = 1
for letter in string:
	if letter == 'A' or letter == 'E' or letter == 'I' or (letter == 'O') or (letter == 'U') or (letter == 'Y'):
		maximum_length = max(maximum_length, length)
		length = 1
	else:
		length += 1
print(max(maximum_length, length))


l = ['A', 'E', 'I', 'O', 'U', 'Y']
s = input()
m = 1
j = 1
for i in s:
	if i in l:
		m = max(m, j)
		j = 1
	else:
		j += 1
m = max(m, j)
print(m)


import math
import collections
import bisect
import heapq
import time
import random
import itertools
import sys
s = input()

def check(s, m):
	vowels = ['A', 'E', 'I', 'O', 'U', 'Y']
	n = len(s)
	dp = [0] * (n + 2)
	dp[0] = 1
	for i in range(n + 2):
		if dp[i]:
			if i + m > n:
				return True
			for j in range(m):
				k = i + j
				if k >= n:
					break
				if s[k] in vowels:
					dp[k + 1] = 1
	return dp[n + 1]
i = 1
while not check(s, i):
	i += 1
print(i)


s = input()
a = ['A', 'E', 'I', 'O', 'U', 'Y']
(k, max) = (1, 1)
if len(s) == 1:
	print(1 if s[0] in a else 2)
else:
	for i in range(len(s)):
		if s[i] not in a:
			k += 1
			if k > max:
				max = k
		elif s[i] in a:
			k = 1
	print(max)


vowels = 'AEIOUY'
s = input()
c = 1
hc = 1
for i in s:
	if i in vowels:
		hc = max(hc, c)
		c = 1
	else:
		c += 1
print(max(hc, c))


import sys
a = sys.stdin.read()
a = a.strip().replace('\n', '')
maxdist = 0
a = 'A' + a + 'A'
for i in range(len(a)):
	if a[i] in 'AEIOUY':
		for j in range(i + 1, len(a)):
			if a[j] in 'AEIOUY':
				if j - i > maxdist:
					maxdist = j - i
				break
print(maxdist)


w = input()
(count, m) = (1, 0)
for c in w:
	if c not in 'AEIOUY':
		count += 1
	else:
		m = max(count, m)
		count = 1
print(max(count, m))


n = input()
c = 1
t = 0
for i in n:
	if i in 'AEIOUY':
		if t < c:
			t = c
		c = 1
	else:
		c += 1
if t < c:
	t = c
print(t)


a = input()
x = 'AEIOUY'
y = 0
z = 0
for i in a:
	if i in x:
		y = 0
	else:
		y += 1
	z = max(z, y)
print(z + 1)


s = input()
a = [0]
for i in range(len(s)):
	if s[i] == 'A' or s[i] == 'E' or s[i] == 'I' or (s[i] == 'O') or (s[i] == 'U') or (s[i] == 'Y'):
		a.append(i + 1)
a.append(len(s) + 1)
d = []
for j in range(1, len(a)):
	d.append(a[j] - a[j - 1])
print(max(d))


print(max([len(i) + 1 for i in input().replace('A', '-').replace('E', '-').replace('I', '-').replace('O', '-').replace('U', '-').replace('Y', '-').split('-')]))


s = input()
s = 'A' + s + 'A'
glasn = ['A', 'E', 'I', 'O', 'U', 'Y']
start = 0
f = 1
maxlen = 1
for i in range(0, len(s)):
	if s[i] in glasn:
		if f:
			start = i
			f = 0
		else:
			if i - start > maxlen:
				maxlen = i - start
			start = i
print(maxlen)


s = input()
s = ' ' + s
jump = 1
vowels = set(list('AEIOUY'))
prev = 0
check = 0
for i in s:
	if i in vowels:
		check = 1
		break
i = 1
if check > 0:
	while i < len(s):
		if s[i] in vowels:
			jump = max(jump, i - prev)
			prev = i
		i += 1
	jump = max(jump, i - prev)
	print(jump)
else:
	print(len(s))


s = list(input())
n = len(s)
pos = []
for i in range(n):
	if 'AEIOUY'.find(s[i]) > -1:
		pos.append(i)
res = 0
for i in range(1, len(pos)):
	res = max(res, pos[i] - pos[i - 1])
if len(pos) > 0:
	res = max(res, pos[0] + 1)
	res = max(res, n - pos[len(pos) - 1])
if len(pos) == 0:
	res = max(res, n + 1)
print(res)


s = input() + 'A'
(i, r) = (-1, 0)
for j in range(len(s)):
	if s[j] in 'AEIOUY':
		r = max(r, j - i)
		i = j
print(r)


str = input()
Vowels = ['A', 'E', 'I', 'O', 'U', 'Y']
length = len(str)
pos = [-1]
pos_len = 0
for i in range(length):
	if str[i] in Vowels:
		pos.append(i + 1)
		pos_len += 1
		if pos_len > 1:
			MinL = max(MinL, pos[pos_len] - pos[pos_len - 1])
		else:
			MinL = i + 1
if pos_len == 0:
	print(length + 1)
else:
	MinL = max(MinL, length - pos[pos_len] + 1)
	print(MinL)


n = input()
a = n.lower()
l = [0]
for i in range(len(n)):
	if a[i] == 'a' or a[i] == 'e' or a[i] == 'i' or (a[i] == 'o') or (a[i] == 'u') or (a[i] == 'y'):
		l.append(i + 1)
l.append(len(n) + 1)
res = []
for i in range(len(l) - 1):
	res.append(l[i + 1] - l[i])
print(max(res))


str = input()
str = str.replace('A', ' ')
str = str.replace('O', ' ')
str = str.replace('E', ' ')
str = str.replace('I', ' ')
str = str.replace('U', ' ')
str = str.replace('Y', ' ')
sp = [len(x) for x in str.split()]
if not sp:
	print(1)
else:
	print(max(sp) + 1)


vowels = ['A', 'E', 'I', 'O', 'U', 'Y']

def solve(r):
	n = len(r)
	X = [0] + [i + 1 for i in range(n) if r[i] in vowels] + [n + 1]
	m = 0
	for i in range(len(X) - 1):
		m = max(m, X[i + 1] - X[i])
	return m
s = input()
print(solve(s))


path = input()
vowels = set('AEIOUY')
jump = 1
max_jump = 1
for letter in path:
	if letter not in vowels:
		jump += 1
		if jump > max_jump:
			max_jump = jump
	else:
		jump = 1
print(max_jump)


n = input()
sonor = ['A', 'O', 'U', 'I', 'E', 'Y']
min = 0
count = 1
for c in n:
	if c in sonor:
		if count > min:
			min = count
		count = 1
	else:
		count += 1
if count > min:
	min = count
if min == 0:
	print(count)
else:
	print(min)


a = input()
a = a.strip()
l = len(a)
s = set('AEIOUY')
pre = -1
Max = 0
for i in range(l):
	if a[i] in s:
		temp = i - pre
		pre = i
		if Max < temp:
			Max = temp
Max = max(Max, l - pre)
print(Max)


a = input()
a = ' '.join(a)
a = a.split()
a.append('A')
c = 1
list1 = []
for i in range(len(a)):
	if a[i] == 'A' or a[i] == 'E' or a[i] == 'I' or (a[i] == 'O') or (a[i] == 'U') or (a[i] == 'Y'):
		list1.append(c)
		c = 1
	else:
		c += 1
print(max(list1))


l = list(input())
v = ['A', 'E', 'I', 'O', 'U', 'Y']
m = 0
last = -1
for i in range(len(l)):
	if l[i] in v:
		m = max(m, i - last)
		last = i
print(max(m, len(l) - last))


s = input()
v = ['A', 'E', 'I', 'O', 'U', 'Y']
ans = 0
for i in range(len(s)):
	for j in range(i + 1, len(s)):
		if s[i] in v and s[j] in v:
			ans = max(ans, j - i)
			break
for i in range(len(s)):
	if s[i] in v:
		ans = max(ans, i + 1)
		break
for i in range(len(s) - 1, -1, -1):
	if s[i] in v:
		ans = max(ans, len(s) - i)
		break
flag = 1
for i in range(len(s)):
	if s[i] in v:
		flag = 0
		break
if flag:
	ans = max(ans, len(s) + 1)
print(ans)


jump = ['A', 'E', 'I', 'O', 'U', 'Y']
ans = 1
s = input()
j = 1
for i in s:
	if i in jump:
		ans = max(ans, j)
		j = 0
	j += 1
ans = max(ans, j)
print(ans)


sen = input()
glasn = ['A', 'E', 'O', 'I', 'U', 'Y']
max = 0
i = 0
for s in sen:
	if s in glasn:
		i += 1
		if i > max:
			max = i
		i = 0
		finish = True
	else:
		i += 1
		finish = False
if finish == False:
	if i + 1 > max:
		max = i + 1
print(max)


st = input()
string = st + 'A'
c = 1
tc = 1
glasn = ['A', 'E', 'I', 'O', 'U', 'Y']
for i in string:
	if i not in glasn:
		tc += 1
	else:
		if c < tc:
			c = tc
		tc = 1
print(c)


w = input().lower()
v = ['a', 'e', 'i', 'o', 'u', 'y']
a = 1
m = 1
for x in w:
	if x not in v:
		m += 1
	elif x in v:
		if m > a:
			a = m
		m = 1
if m > a:
	a = m
print(a)


S = input()
cnt = 0
mx = 1
for s in S:
	cnt += 1
	if s in 'AEIOUY':
		if cnt > mx:
			mx = cnt
		cnt = 0
cnt += 1
if cnt > mx:
	mx = cnt
print(mx)


s = input()
oi = -1
ans = 0
for (i, c) in enumerate(s):
	if c in 'AEIOUY':
		ans = max(ans, i - oi)
		oi = i
ans = max(ans, len(s) - oi)
print(ans)


a = b = 1
for i in input():
	if i == 'A' or i == 'E' or i == 'I' or (i == 'O') or (i == 'U') or (i == 'Y'):
		a = max(a, b)
		b = 1
	else:
		b += 1
print(max(a, b))


text = input()

def transform(x):
	if x in ['A', 'E', 'I', 'O', 'U', 'Y']:
		return 1
	else:
		return 0
text = list(map(transform, text))
maxjump = 0
current = 1
for k in text:
	if k == 0:
		current += 1
	else:
		maxjump = max(maxjump, current)
		current = 1
maxjump = max(maxjump, current)
print(maxjump)


vowels = ['A', 'E', 'I', 'O', 'U', 'Y']
jump_counter = 1
highest_jump = []
jump_gh = input().upper()
for letter in jump_gh:
	if letter in vowels:
		jump_counter = 0
		jump_counter = jump_counter + 1
		highest_jump.append(jump_counter)
		continue
	elif letter not in vowels:
		jump_counter += 1
		highest_jump.append(jump_counter)
max = 0
for i in highest_jump:
	if i > max:
		max = i
print(max)


vl = 'AEIOUY'
s = input()
ans = -1
(j, k) = (0, 0)
for i in s:
	j += 1
	if i in vl:
		ans = max(ans, j - k)
		k = j
j += 1
ans = max(ans, j - k)
print(ans)


str = input()
vowels = 'AEIOUY'
max_dist = -float('inf')
cur_dist = 0
for c in str:
	cur_dist += 1
	if c in vowels:
		(max_dist, cur_dist) = (max(max_dist, cur_dist), 0)
max_dist = max(max_dist, cur_dist + 1)
print(max_dist)


string = input()
string_used = string + 'A'
minimum_jump_ability = 0
jump_ability = 0
jumps = 0
vowels = ['A', 'E', 'I', 'O', 'U', 'Y']
for grasshopper in string_used:
	jumps += 1
	if grasshopper in vowels:
		jump_ability += jumps
		jumps = 0
		if jump_ability > minimum_jump_ability:
			minimum_jump_ability = jump_ability
			jump_ability = 0
		else:
			jump_ability = 0
print(minimum_jump_ability)


inp = str(input())
cons = 0
con = 0
vowels = ['A', 'E', 'I', 'O', 'U', 'Y']
for i in inp:
	if i in vowels:
		con = 0
	else:
		con += 1
		if con > cons:
			cons = con
print(str(cons + 1))


s = input()
sol = 0
cnt = 1
vowels = 'AEIOUY'
s = s + 'A'
for x in s:
	if x in vowels:
		sol = max(sol, cnt)
		cnt = 1
	else:
		cnt += 1
print(sol)


def isvowel(s):
	if s == 'A' or s == 'E' or s == 'I' or (s == 'O') or (s == 'U') or (s == 'Y'):
		return True
	return False

def solve():
	s = input()
	res = 1
	count = 1
	for i in range(len(s)):
		if isvowel(s[i]):
			if res < count:
				res = count
			count = 1
		else:
			count += 1
	if res < count:
		res = count
	print(res)
solve()


string = input()
string += 'A'
pos = [int(-1)]
for i in range(len(string)):
	if string[i] in 'AEIOUY':
		pos.append(i)
best = int(0)
for i in range(1, len(pos)):
	best = max(best, pos[i] - pos[i - 1])
print(best)


vowels = 'AEIOUY'
s = list(input())
counter = 0
ans = 0
if len(s) > 1:
	found = False
	for i in range(len(s)):
		if s[i] in vowels:
			found = True
			if counter > ans:
				ans = counter
			counter = 0
			continue
		counter += 1
	if counter > ans:
		ans = counter
	if found:
		print(ans + 1)
	else:
		print(len(s) + 1)
elif s[0] in vowels:
	print(1)
else:
	print(2)


inpStr = input()
vowels = ['A', 'E', 'I', 'O', 'U', 'Y']
maxJump = 1
curJump = 1
for e in inpStr:
	if e not in vowels:
		curJump += 1
	else:
		if curJump > maxJump:
			maxJump = curJump
		curJump = 1
if curJump > maxJump:
	maxJump = curJump
print(maxJump)


v = 'AEIOUY'
ind = -1
maxx = 0
s = input() + 'A'
for i in range(len(s)):
	if s[i] in v:
		maxx = max(i - ind, maxx)
		ind = i
print(maxx)


s = input() + 'A'
pr = 0
i = -1
st = -1
while i < len(s):
	if s[i] in set('AEIOUY'):
		cpr = i - st
		if cpr > pr:
			pr = cpr
		st = i
	i += 1
print(pr)


def main():
	vowels = 'AEIOUY'
	paper = input()
	current_max = 0
	current = 0
	for c in paper:
		current += 1
		if c in vowels:
			if current > current_max:
				current_max = current
			current = 0
	current += 1
	if current > current_max:
		current_max = current
	print(current_max)
main()


s = str(input())
list1 = ['A', 'E', 'I', 'O', 'U', 'Y']
list2 = [0]
for i in range(len(s)):
	if s[i] in list1:
		list2.append(i + 1)
m = 0
list2.append(len(s) + 1)
for i in range(len(list2) - 1):
	if list2[i + 1] - list2[i] > m:
		m = list2[i + 1] - list2[i]
print(m)


val = input()
v = {'A', 'E', 'I', 'O', 'U', 'Y'}
max_jump = 0
jump = 1
for i in val:
	if i in v:
		if jump > max_jump:
			max_jump = jump
		jump = 1
	else:
		jump += 1
if jump > max_jump:
	max_jump = jump
print(max_jump)


s = input()
G = ('A', 'E', 'I', 'O', 'U', 'Y')
A = [-1]
minL = 0
L = len(s)
for i in range(L):
	if s[i] in G:
		A.append(i)
for i in range(len(A) - 1):
	if A[i + 1] - A[i] > minL:
		minL = A[i + 1] - A[i]
if len(A) == 1:
	print(L + 1)
elif len(A) == 2:
	print(max(A[1] + 1, L - A[1]))
else:
	print(max(minL, L - A[len(A) - 1]))


string = input()
counter = 0
v = []
for x in string:
	counter += 1
	if x == 'A' or x == 'E' or x == 'I' or (x == 'O') or (x == 'U') or (x == 'Y'):
		v.append(counter)
		counter = 0
v.append(counter + 1)
print(max(v))


start = 'A'
end = 'A'
s = input()
s = start + s + end
lets = ['A', 'E', 'I', 'O', 'U', 'Y']
res = []
c = 1
for i in s:
	if i in lets:
		res.append(c)
		c = 1
	else:
		c += 1
print(max(res))


from __future__ import print_function

def solve():
	s = input('').strip()
	s = s + 'A'
	vowels = 'AEIOUY'
	a = 1
	x = -1
	for i in range(len(s)):
		if s[i] in vowels:
			a = max(a, i - x)
			x = i
	print(a)

def main():
	solve()
main()


S = input()
vowels = 'AEIOUY'
now = -1
ans = 0
for (i, s) in enumerate(S):
	if s in vowels:
		ans = max(i - now, ans)
		now = i
if now == -1:
	ans = len(S) + 1
else:
	for (i, s) in enumerate(S[::-1]):
		if s in vowels:
			ans = max(ans, i + 1)
			break
print(ans)


line = 'A' + str(input()) + 'A'
size = len(line)
note = last = 0
for i in range(size):
	if line[i] in ['A', 'E', 'I', 'O', 'U', 'Y']:
		note = max(note, i - last)
		last = i
print(note)


s = input()
d = ['A', 'E', 'I', 'O', 'U', 'Y']
p = 0
m = 0
for i in range(len(s)):
	if s[i] in d:
		if i + 1 - p > m:
			m = i + 1 - p
		p = i + 1
if len(s) + 1 - p > m:
	m = len(s) + 1 - p
print(m)


a = input()
b = ['A', 'E', 'I', 'O', 'U', 'Y']
m = 1
c = 0
for i in range(len(a)):
	if a[i] in b:
		c = 0
	else:
		c += 1
	m = max(m, c + 1)
print(m)


s = input()
ans = 1
cnt = 0
for c in s:
	cnt += 1
	if c in ['A', 'I', 'U', 'E', 'O', 'Y']:
		ans = max(cnt, ans)
		cnt = 0
ans = max(ans, cnt + 1)
print(ans)


import sys
input = sys.stdin.readline

def ceil(x):
	if x != int(x):
		x = int(x) + 1
	return x

def factorial(x, m):
	val = 1
	while x > 0:
		val = val * x % m
		x -= 1
	return val

def swaparr(arr, a, b):
	temp = arr[a]
	arr[a] = arr[b]
	arr[b] = temp

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

def nCr(n, k):
	if k > n - k:
		k = n - k
	res = 1
	for i in range(k):
		res = res * (n - i)
		res = res / (i + 1)
	return int(res)

def upper_bound(a, x, lo=0, hi=None):
	if hi == None:
		hi = len(a)
	while lo < hi:
		mid = (lo + hi) // 2
		if a[mid] < x:
			lo = mid + 1
		else:
			hi = mid
	return lo

def primefs(n):
	primes = {}
	while n % 2 == 0 and n > 0:
		primes[2] = primes.get(2, 0) + 1
		n = n // 2
	for i in range(3, int(n ** 0.5) + 2, 2):
		while n % i == 0 and n > 0:
			primes[i] = primes.get(i, 0) + 1
			n = n // i
	if n > 2:
		primes[n] = primes.get(n, 0) + 1
	return primes

def power(x, y, p):
	res = 1
	x = x % p
	if x == 0:
		return 0
	while y > 0:
		if y & 1 == 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res

def swap(a, b):
	temp = a
	a = b
	b = temp
	return (a, b)

def find(x, link):
	p = x
	while p != link[p]:
		p = link[p]
	while x != p:
		nex = link[x]
		link[x] = p
		x = nex
	return p

def union(x, y, link, size):
	x = find(x, link)
	y = find(y, link)
	if size[x] < size[y]:
		(x, y) = swap(x, y)
	if x != y:
		size[x] += size[y]
		link[y] = x

def sieve(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	return prime
MAXN = int(100000.0 + 5)

def spf_sieve():
	spf[1] = 1
	for i in range(2, MAXN):
		spf[i] = i
	for i in range(4, MAXN, 2):
		spf[i] = 2
	for i in range(3, ceil(MAXN ** 0.5), 2):
		if spf[i] == i:
			for j in range(i * i, MAXN, i):
				if spf[j] == j:
					spf[j] = i

def factoriazation(x):
	ret = {}
	while x != 1:
		ret[spf[x]] = ret.get(spf[x], 0) + 1
		x = x // spf[x]
	return ret

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

def float_array():
	return list(map(float, input().strip().split()))

def str_array():
	return input().strip().split()
MOD = int(1000000000.0) + 7
CMOD = 998244353
INF = float('inf')
NINF = -float('inf')
from itertools import permutations
import math

def solve():
	s = input().lower()
	j = 0
	m = 0
	for i in range(1, len(s) + 1):
		if s[i - 1] in 'aeiouy':
			m = max(m, abs(i - j))
			j = i
	m = max(len(s) - j, m)
	if m == 0:
		print(len(s))
		return
	print(m)
for _ in range(1):
	solve()


string = input()
lst = []
for i in range(len(string)):
	if string[i] in 'AEOUIY':
		lst.append(i)
lst = sorted(lst)
lst2 = []
for i in range(len(lst) - 1):
	lst2.append(abs(lst[i] - lst[i + 1]))
if len(lst) == 0:
	print(len(string) + 1)
else:
	lst2.append(lst[0] + 1)
	lst2.append(len(string) - lst[len(lst) - 1])
	print(max(lst2))


import re
s = input()
print(len(max(re.split('[AEIOUY]', s), key=len)) + 1)


import sys
a = input()
m = -1
mini = -1
vowels = ['A', 'E', 'I', 'O', 'U', 'Y']
for i in range(len(a)):
	if a[i] in vowels:
		if i - m > mini:
			mini = i - m
		m = i
if i + 1 - m > mini:
	mini = i + 1 - m
print(mini)


string = input()
l = len(string)
vowel = ['A', 'E', 'I', 'O', 'U', 'Y']
start = -1
jump = 1
for i in range(l):
	if string[i] in vowel:
		jump = max(i - start, jump)
		start = i
jump = max(jump, l - start)
print(jump)


a = input()
vowels = 'AEIOUY'
for char in a:
	if char in vowels:
		a = a.replace(char, '0')
	else:
		a = a.replace(char, '1')
a = a.split('0')
max = 0
for i in a:
	if len(i) > max:
		max = len(i)
print(max + 1)


mx = []
a = input() + 'A'
jump = 0
for i in range(len(a)):
	if a[i] in ['A', 'E', 'I', 'O', 'U', 'Y']:
		mx.append(jump + 1)
		jump = 0
	else:
		jump += 1
mx.append(jump)
print(max(mx))


def grasshopperJump(s):
	vowels = ['A', 'E', 'I', 'O', 'U', 'Y']
	max_jump = 1
	pos = -1
	while pos < len(s):
		end = pos + 1
		while end < len(s) and s[end] not in vowels:
			end += 1
		current_jump = end - pos
		max_jump = max(max_jump, current_jump)
		pos = end
	return max_jump
s = input()
print(grasshopperJump(s))


s = input() + 'A'
m = 0
last = -1
vowels = {c for c in 'AEIOUY'}
for (i, c) in enumerate(s):
	if c in vowels:
		d = i - last
		if d > m:
			m = d
		last = i
print(m)


alf = ['A', 'E', 'I', 'O', 'U', 'Y']
string = input()
max = 1
count = 1
for i in range(len(string)):
	for j in range(len(alf)):
		if string[i] == alf[j]:
			if count > max:
				max = count
			count = 0
	count += 1
	if count > max:
		max = count
print(max)


st = list(input())
vo = list('AEIOUY')
ability = 0
co = 1
for i in range(len(st)):
	if st[i] in vo:
		if co > ability:
			ability = co
		co = 1
	else:
		co += 1
if co > ability:
	ability = co
print(ability)


def solve(a):
	l = [0]
	li = []
	j = 0
	for i in range(len(a)):
		if a[i] == 'A' or a[i] == 'E' or a[i] == 'I' or (a[i] == 'O') or (a[i] == 'U') or (a[i] == 'Y'):
			l.append(i + 1)
			j += 1
			li.append(l[j] - l[j - 1])
	l.append(i + 1)
	j += 1
	li.append(l[j] - l[j - 1] + 1)
	li.sort()
	print(li[-1])
solve(input())


ss = input()
c = 0
maxs = 0
for s in ss:
	if s == 'A' or s == 'E' or s == 'I' or (s == 'O') or (s == 'U') or (s == 'Y'):
		c = 0
	else:
		c += 1
		if maxs <= c:
			maxs = c
print(maxs + 1)


import sys
import itertools
vowels = set(['A', 'E', 'I', 'O', 'U', 'Y'])

def main():
	string = input()
	for jmplen in itertools.count(start=1):
		cur = -1
		while True:
			changed = False
			for i in range(cur + jmplen, cur, -1):
				if i >= len(string):
					cur = len(string)
					break
				c = string[i]
				if c in vowels:
					cur = i
					changed = True
					break
			if cur == len(string):
				print(jmplen)
				sys.exit(0)
			elif not changed:
				break
main()


s = input()
p = 1
l = 0
for i in range(len(s)):
	if s[i] == 'A' or s[i] == 'O' or s[i] == 'Y' or (s[i] == 'E') or (s[i] == 'U') or (s[i] == 'I'):
		if p > l:
			l = p
		p = 1
	else:
		p = p + 1
		if p > l:
			l = p
print(l)


jumps = [0]
s = input()
a = 0
for i in s:
	a = a + 1
	jumps.append(a)
	if i == 'A' or i == 'E' or i == 'I' or (i == 'O') or (i == 'U') or (i == 'Y'):
		a = 0
jumps.append(a + 1)
print(max(jumps))


ruler = input()
vowels = 'A E I O U Y'.split()
jump = jump_max = 1
for letter in ruler:
	jump += 1
	if letter in vowels:
		jump = 1
	if jump_max < jump:
		jump_max = jump
print(jump_max)


s = input()
s = s + 'A'
ability = 0
last = 0
index = 1
for i in s:
	ability = max(index - last, ability)
	if i == 'A' or i == 'E' or i == 'I' or (i == 'O') or (i == 'U') or (i == 'Y'):
		last = index
	index += 1
print(ability)


lawn = input()
curr = 0
jumps = []
for i in range(0, len(lawn)):
	if lawn[i] in 'AEIOUY':
		jumps.append(i - curr + 1)
		curr = i + 1
jumps.append(len(lawn) + 1 - curr)
print(max(jumps))


ct = 0
l = [0]
for i in input() + 'A':
	if i in 'AEIOUY':
		l.append(ct)
		ct = 0
	else:
		ct += 1
print(max(l) + 1)


s = input()
last = 1
maxx = 0
for i in range(len(s)):
	if s[i] in 'AOUIEY':
		maxx = max(maxx, last)
		last = 1
	else:
		last += 1
print(max(maxx, last))


a = input()
z = ['A', 'E', 'I', 'O', 'U', 'Y']
f = 0
c = 1
for i in a:
	if i in z:
		c = 1
	else:
		c += 1
	f = max(f, c)
f = max(f, c)
print(f)


s = input()
a = ['A', 'E', 'I', 'O', 'U', 'Y']
l = 1
k = 1
i = 0
while i != len(s):
	if not s[i] in a:
		while i < len(s) and (not s[i] in a):
			k += 1
			i += 1
		l = max(k, l)
		k = 1
	else:
		i += 1
print(l)


from sys import stdin
max_val = int(10000000000000.0)
min_val = int(-10000000000000.0)

def read_int():
	return int(stdin.readline())

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

def read_str():
	return input()

def read_strs():
	return [x for x in stdin.readline().split()]
import re
s = input()
print(len(max(re.split('[AEIOUY]', s), key=len)) + 1)


s = input()
s = 'A' + s + 'A'
pre = 0
z = 1
for i in range(len(s)):
	if s[i] in 'AEUIOY':
		z = max(z, i - pre)
		pre = i
print(z)


ans = 1
s = input()
m = 1
vowel = ['A', 'E', 'I', 'O', 'U', 'Y']
for i in range(len(s)):
	if s[i] not in vowel:
		m += 1
		ans = max(ans, m)
	else:
		m = 1
print(ans)


import sys

def main():
	input = sys.stdin.readline().strip()
	prev = -1
	maxStep = 0
	for (i, ch) in enumerate(input):
		if ch == 'A' or ch == 'E' or ch == 'I' or (ch == 'O') or (ch == 'U') or (ch == 'Y'):
			maxStep = max(abs(i - prev), maxStep)
			prev = i
	maxStep = max(len(input) - prev, maxStep)
	print(maxStep)
main()


s = input()
vocals = ['A', 'E', 'I', 'O', 'U', 'Y']
last_vocal_ind = -1
max_dist = 0
for i in range(len(s)):
	if s[i] in vocals:
		max_dist = max(max_dist, i - last_vocal_ind)
		last_vocal_ind = i
print(max(max_dist, len(s) - last_vocal_ind))


l = ['A', 'E', 'I', 'O', 'U', 'Y']
s = input() + 'A'
m = 0
prev = -1
for (i, c) in enumerate(s):
	if c in l:
		m = max(m, i - prev)
		prev = i
print(m)


s = input()
a = 'AOUYEI'
s += 'A'
ans = -1
now = -1
n = len(s)
for i in range(0, n):
	if s[i] in a:
		ans = max(ans, i - now)
		now = i
print(ans)


from functools import reduce
from operator import add
import re

def main():
	try:
		while True:
			print(reduce(max, (len(m.group()) for m in re.finditer('[^AEIOUY]+', input())), 0) + 1)
	except EOFError:
		pass
main()


n = input()
k = [i + 1 for i in range(len(n)) if n[i] in ['A', 'E', 'I', 'O', 'U', 'Y']]
k.insert(0, 0)
k.append(len(n) + 1)
print(max([k[i + 1] - k[i] for i in range(len(k) - 1)]))


a = input()
a += ' '
buff = 'AEIOUY '
n = -1
k = 0
answ = 0
for i in range(len(a)):
	if a[i] in buff:
		k = i - n
		n = i
	if k > answ:
		answ = k
print(answ)


import re
print(max(map(len, re.split('[AEIOUY]', input()))) + 1)


s = list(input())
j = 1
q = -1
v = ['A', 'E', 'I', 'O', 'U', 'Y']
for i in range(len(s)):
	if s[i] in v:
		j = max(i - q, j)
		q = i
j = max(len(s) - q, j)
print(j)


s = input()
a = ['A', 'E', 'I', 'O', 'U', 'Y']
cnt = 0
res = []
for i in range(len(s)):
	if s[i] in a:
		res.append(cnt + 1)
		cnt = 0
	else:
		cnt += 1
res.append(cnt + 1)
print(max(res))


a = input().lower()
a = 'a' + a + 'a'
b = []
e = 0
bb = 'aeiouy'
for i in range(len(a)):
	if a[i] in bb:
		b.append(i)
for i in range(len(b) - 1):
	if b[i + 1] - b[i] > e:
		e = b[i + 1] - b[i]
print(e)


s = str(input())
n = len(s)
d = -1
r = 0
V = 'AEIOUY'
for i in range(n):
	if V.count(s[i]):
		r = max(r, i - d)
		d = i
print(max(r, n - d))


s = 'A' + input() + 'A'
max_l = 0
pred_vowel_i = 0
for i in range(1, len(s)):
	if s[i] in 'AEOIUY':
		max_l = max(max_l, i - pred_vowel_i)
		pred_vowel_i = i
print(max_l)


s = input()
pr = 1
maxpr = 0
for i in range(len(s)):
	if s[i] != 'A' and s[i] != 'E' and (s[i] != 'I') and (s[i] != 'O') and (s[i] != 'U') and (s[i] != 'Y'):
		pr += 1
	else:
		if pr > maxpr:
			maxpr = pr
		pr = 1
if pr > maxpr and maxpr != 0 and (pr != 1):
	maxpr = pr
if s.count('A') == 0 and s.count('E') == 0 and (s.count('I') == 0) and (s.count('O') == 0) and (s.count('U') == 0) and (s.count('Y') == 0):
	maxpr = len(s) + 1
print(maxpr)


s = input()
vowels = {'A', 'O', 'U', 'I', 'Y', 'E'}
cur_len = 0
max_len = 0
for (i, ch) in enumerate(s):
	if ch in vowels:
		max_len = max(max_len, cur_len + 1)
		cur_len = 0
	else:
		cur_len += 1
max_len = max(max_len, cur_len + 1)
print(max_len)


def solve(s):
	cur = 0
	maxi = 0
	for i in s[1:]:
		if i in 'AEIOUY':
			cur += 1
			maxi = max(maxi, cur)
			cur = 0
		else:
			cur += 1
	return maxi

def main():
	s = 'A' + input() + 'A'
	print(solve(s))
main()


s = 'A' + input() + 'A'
G = {'A', 'E', 'I', 'O', 'U', 'Y'}
ans = 1
t = 0
for i in s:
	if i not in G:
		t += 1
		if t > ans:
			ans = t
	else:
		t = 1
print(ans)


string = str.upper(input())
vowels = ['A', 'E', 'I', 'O', 'U', 'Y']
jumps = []
jump = 1
for c in string:
	if c in vowels:
		jumps.append(jump)
		jump = 1
	else:
		jump += 1
jumps.append(jump)
print(max(jumps))


d = max_d = 1
for ch in input():
	if ch in 'AEIOUY':
		(d, max_d) = (1, max(d, max_d))
	else:
		d += 1
print(max(d, max_d))


n = input()
m = -1
pos = 0
vowels = 'AOEUIY'
for ch in n:
	pos += 1
	if ch in vowels:
		m = max(m, pos)
		pos = 0
pos = pos + 1 if n[-1] not in vowels else pos
m = max(pos, m)
print(m)


v = ['A', 'E', 'I', 'O', 'U', 'Y']

def fun(c, ss):
	if not ss:
		return c
	if ss[0] in v:
		return max(c, fun(1, ss[1:]))
	return fun(c + 1, ss[1:])
ss = input()
print(fun(1, ss))


l = input()
k = 1
ma = 0
a = ['A', 'E', 'I', 'O', 'U', 'Y']
for i in range(len(l)):
	if a.count(l[i]) > 0:
		k = 1
		if k > ma:
			ma = k
	else:
		k = k + 1
		if k > ma:
			ma = k
print(ma)


st = input()
leng = len(st)
last_dis = 0
ans = 0
for i in range(0, leng):
	if st[i] == 'A' or st[i] == 'E' or st[i] == 'I' or (st[i] == 'O') or (st[i] == 'U') or (st[i] == 'Y'):
		ans = max(ans, last_dis)
		last_dis = 0
	else:
		last_dis += 1
ans = max(ans, last_dis)
print(ans + 1)


s = input()
f = 0
p = 1
v = {'A', 'E', 'I', 'O', 'Y', 'U'}
for i in s:
	f = f + 1
	if i in v:
		if f > p:
			p = f
		f = 0
if f >= p:
	print(f + 1)
else:
	print(p)


s = input()
str = ''
str += 'A'
str += s
str += 'A'
(maxi, count) = (0, 0)
for i in str:
	if i != 'A' and i != 'E' and (i != 'I') and (i != 'O') and (i != 'U') and (i != 'Y'):
		count += 1
		maxi = max(maxi, count)
	else:
		count = 0
print(maxi + 1)


s = input('')
w = 'AEIOUY'
a = -1
b = -1
ans = 0
for i in range(len(s)):
	if s[i] in w:
		b = a
		a = i
		ans = max(ans, a - b)
ans = max(ans, len(s) - a)
print(ans)


from operator import *
s = [x for (x, y) in enumerate('A' + input() + 'A') if y in 'AIOUEY']
print(max(map(sub, s[1:], s)))


s = input()
vowels = ['A', 'E', 'I', 'O', 'U', 'Y']
ans = 0
pre = -1
for i in range(len(s)):
	if s[i] in vowels:
		ans = max(ans, i - pre)
		pre = i
ans = max(ans, len(s) - pre)
print(ans)


string = input()
vowels = ['A', 'E', 'I', 'O', 'U', 'Y']
JA = 0
beg = 0
isVowels = False
for i in range(1, len(string) + 1):
	if string[i - 1] in vowels:
		cur_JA = i - beg
		beg = i
		isVowels = True
		if cur_JA > JA:
			JA = cur_JA
last = i + 1 - beg
if last > JA:
	JA = last
if isVowels:
	print(JA)
else:
	print(len(string) + 1)


a = 'AEIOUY'
b = input()
now = 0
maxi = 0
for i in b:
	if i in a:
		now = 0
	else:
		now += 1
		if now > maxi:
			maxi = now
print(maxi + 1)


road = input().strip()
mn = current = 1
vowels = 'AEIOUY'
for c in road:
	if c not in vowels:
		current += 1
	else:
		current = 1
	mn = max(mn, current)
print(mn)


s = input() + 'A'
jumps = {'A', 'E', 'I', 'O', 'U', 'Y'}
mx = 0
temp = 0
for char in s:
	if char not in jumps:
		temp += 1
	else:
		if temp > mx:
			mx = temp
		temp = 0
print(mx + 1)


s = input()
last = -1
ans = -1
for i in range(len(s)):
	if s[i] in 'AEIOUY':
		ans = max(ans, i - last)
		last = i
ans = max(ans, len(s) - last)
print(ans)


str = input()
s1 = str
s2 = 'A'
str = s2 + s1 + s2
l = len(str)
pos = 0
ans = 0
for i in range(0, l):
	if str[i] == 'A' or str[i] == 'E' or str[i] == 'O' or (str[i] == 'U') or (str[i] == 'I') or (str[i] == 'Y'):
		ans = max(ans, i - pos)
		pos = i
print(ans)


str = input()
str += 'O'
l = len(str)
last = -1
vowel = {'A', 'E', 'I', 'O', 'U', 'Y'}
ans = 0
for i in range(0, l):
	if str[i] in vowel:
		ans = max(ans, i - last)
		last = i
print(ans)


s = [i for (i, c) in enumerate('A' + input() + 'A') if c in 'AEIOUY']
print(max((b - a for (a, b) in zip(s, s[1:]))))


a = ['A', 'E', 'I', 'O', 'U', 'Y']
b = ['0'] + list(input()) + ['A']
ans = []
k = 0
for i in range(len(b)):
	if b[i] in a:
		ans.append(i - k)
		k = i
print(max(ans))


n = input()
arr = []
for i in range(len(n)):
	if n[i] == 'A' or n[i] == 'E' or n[i] == 'I' or (n[i] == 'O') or (n[i] == 'U') or (n[i] == 'Y'):
		arr.append(i)
temp = 1
for i in range(1, len(arr)):
	if abs(arr[i] - arr[i - 1]) > temp:
		temp = abs(arr[i] - arr[i - 1])
if 'A' in n or 'E' in n or 'I' in n or ('O' in n) or ('U' in n) or ('Y' in n):
	if len(arr) == 1:
		print(max(arr[0] + 1, len(n) - arr[0]))
	else:
		print(max(temp, arr[0] + 1, len(n) - arr[-1]))
else:
	print(len(n) + 1)


x = input()
z = 1
i = 0
lst = []
lst2 = ['A', 'E', 'U', 'I', 'O', 'Y']
while i < len(x):
	if x[i] not in lst2:
		z += 1
	else:
		z = 1
	lst.append(z)
	i += 1
print(max(lst))


s = input()
min = 0
lst = [0]
for i in range(len(s)):
	if s[i] == 'A' or s[i] == 'E' or s[i] == 'I' or (s[i] == 'O') or (s[i] == 'U') or (s[i] == 'Y'):
		lst.append(i + 1)
lst.append(len(s) + 1)
if len(lst) == 0:
	min = len(s) + 1
elif len(lst) == 1:
	min = lst[0] + 1
else:
	for i in range(1, len(lst)):
		diff = lst[i] - lst[i - 1]
		if diff > min:
			min = diff
print(min)


str1 = input()
list1 = list(str1)
pos = 0
listNew = []
for i in range(len(list1)):
	if list1[i] == 'A' or list1[i] == 'E' or list1[i] == 'I' or (list1[i] == 'O') or (list1[i] == 'U') or (list1[i] == 'Y'):
		listNew.append(i + 1 - pos)
		pos = i + 1
pos -= 1
listNew.append(len(list1) - pos)
print(max(listNew))


x_1 = -1
x_2 = -1
vovels = 'AEIOUY'
d = 1
s = str(input())
for i in range(len(s)):
	if s[i] in vovels:
		x_1 = x_2
		x_2 = i
	if x_2 - x_1 > d:
		d = x_2 - x_1
if len(s) - x_2 > d:
	d = len(s) - x_2
if x_1 == -1 and x_2 == -1:
	d = len(s) + 1
print(d)


n = input()
n = 'A' + n + 'A'
i = 0
t = 0
ma = 0
for i in range(1, len(n)):
	if n[i] == 'A' or n[i] == 'E' or n[i] == 'Y' or (n[i] == 'U') or (n[i] == 'O') or (n[i] == 'I'):
		if ma < i - t:
			ma = i - t
		t = i
print(ma)


s = input()
v = []
for i in range(len(s)):
	if s[i] == 'A' or s[i] == 'E' or s[i] == 'I' or (s[i] == 'O') or (s[i] == 'U') or (s[i] == 'Y'):
		v.append(i)
v.insert(0, -1)
v.append(len(s))
jump = 1
for i in range(len(v) - 1):
	jump = max(jump, v[i + 1] - v[i])
print(jump)


s = input()
v = 'AEIOUY'
prev = -1
maxi = 0
for i in range(len(s)):
	if s[i] in v:
		maxi = max(maxi, i - prev)
		prev = i
maxi = max(maxi, len(s) - prev)
print(maxi)


s = input()
max = 0
calc = 0
for c in s:
	calc = calc + 1
	if c == 'A' or c == 'E' or c == 'I' or (c == 'O') or (c == 'U') or (c == 'Y'):
		max = calc if calc > max else max
		calc = 0
calc = calc + 1
max = calc if calc > max else max
print(max)


s = input()
vowels = ['A', 'E', 'I', 'O', 'U', 'Y']
c = []
t = 0
for i in s:
	if i in vowels:
		c.append(t + 1)
		t = 0
	else:
		t += 1
t = 1
for i in range(len(s) - 1, -1, -1):
	if s[i] in vowels:
		break
	else:
		t += 1
c.append(t)
print(max(c))


s = input()
l = -1
gl = {'A', 'E', 'I', 'O', 'U', 'Y'}
ans = 0
for (i, ch) in enumerate(s):
	if ch in gl:
		if i - l > ans:
			ans = i - l
		l = i
ans = max(ans, len(s) - l)
print(ans)


st = list(input())
st.append('I')
maxi = 0
start = 0
for x in range(len(st)):
	if st[x] in 'AEIOUY5':
		finish = x + 1
		if finish - start > maxi:
			maxi = finish - start
		start = finish
print(maxi)


chars = {'A', 'E', 'I', 'O', 'U', 'Y'}
data = 'A' + input() + 'A'
last_char_pos = 0
max_char_pos = 0
for i in range(len(data)):
	if data[i] in chars:
		max_char_pos = max(max_char_pos, i - last_char_pos)
		last_char_pos = i
print(max_char_pos)


def vowel(a):
	if a == 'A' or a == 'E' or a == 'I' or (a == 'O') or (a == 'U') or (a == 'Y'):
		return True
	return False
path = input()
path = 'A' + path + 'A'
Min = 0
cp = -1
temp = []
for i in range(len(path)):
	if vowel(path[i]):
		temp.append(1)
	else:
		temp.append(0)
temp = [i for (i, x) in enumerate(temp) if x == 1]
Max = 1
for i in range(len(temp) - 1):
	if temp[i + 1] - temp[i] > Max:
		Max = temp[i + 1] - temp[i]
print(Max)


l = ['A', 'E', 'I', 'O', 'U', 'Y']
s = input()
(z, p) = (0, 0)
for i in range(len(s)):
	if s[i] in l:
		p = 0
		continue
	else:
		p += 1
	z = max(z, p)
print(z + 1)


q = input()
s = 0
m = 0
w = {'A', 'E', 'I', 'O', 'U', 'Y'}
for i in range(len(q)):
	if q[i] in w:
		m = max(m, s)
		s = 0
	else:
		s += 1
m = max(m, s)
print(m + 1)


a = input()
s = ['A', 'E', 'I', 'O', 'U', 'Y']
CNT = []
for i in range(len(a)):
	if a[i] in s:
		CNT.append(i)
if len(CNT) == 1:
	one = len(a) - CNT[0]
	two = CNT[0] + 1
	print(max(one, two))
elif len(CNT) == 0:
	print(len(a) + 1)
else:
	Dis = []
	for m in range(1, len(CNT)):
		dis = CNT[m] - CNT[m - 1]
		Dis.append(dis)
	mm = max(Dis)
	value = max(mm, CNT[0] + 1, len(a) - CNT[-1])
	print(value)


string = input()
jump = 1
maxjump = 1
for c in string:
	if c == 'A' or c == 'E' or c == 'I' or (c == 'O') or (c == 'U') or (c == 'Y'):
		jump = 1
	else:
		jump += 1
		if jump > maxjump:
			maxjump = jump
print(maxjump)


grass = input()
last = -1
mn = 0
for i in range(0, len(grass)):
	if ['A', 'E', 'I', 'O', 'U', 'Y'].count(grass[i]) > 0:
		if mn < i - last:
			mn = i - last
		last = i
if mn < len(grass) - last:
	mn = len(grass) - last
print(mn)


X = input()
MIN = 1
X = 'A' + X + 'A'
PREV = 0
for i in range(1, len(X)):
	if X[i] in 'AEIOUY':
		MIN = max(MIN, i - PREV)
		PREV = i
print(MIN)


stri = input()
prev = -1
maxi = -999999
vowel = 'AEIOUY'
i = 0
for (i, j) in enumerate(stri):
	if vowel.find(j) != -1:
		maxi = max(i - prev, maxi)
		prev = i
maxi = max(i - prev + 1, maxi)
print(maxi)


a = input()
mxcnt = 1
n = len(a)
cnt = 1
for i in range(n + 1):
	if i == n or a[i] == 'A' or a[i] == 'E' or (a[i] == 'I') or (a[i] == 'U') or (a[i] == 'Y') or (a[i] == 'O'):
		mxcnt = max(cnt, mxcnt)
		cnt = 1
	else:
		cnt += 1
print(mxcnt)


r = 0
t = -1
for (i, x) in enumerate(input() + 'A'):
	if x in 'AEIOUY':
		r = max(r, i - t)
		t = i
print(r)


l = input()
vov = ['A', 'E', 'I', 'O', 'U', 'Y']
i = 0
table = []
prev = -1
while i < len(l):
	if l[i] in vov:
		table.append(i - prev)
		prev = i
	i += 1
table.append(len(l) - prev)
print(max(table))


result = 1
chain = 1
str = input()
for char in str:
	if char in ['A', 'E', 'I', 'O', 'U', 'Y']:
		if chain > result:
			result = chain
		chain = 1
	else:
		chain += 1
if chain > result:
	result = chain
print(result)


from sys import stdin

def get_ints():
	return list(map(int, stdin.readline().strip().split()))
s = input()
n = len(s)
ar = [0] * n
cnt = 1
bad = set(['A', 'O', 'E', 'Y', 'I', 'U'])
res = []
for i in range(n):
	if s[i] in bad:
		res.append(cnt)
		cnt = 1
		continue
	cnt += 1
res.append(cnt)
print(max(res))


s = input()
m = 1
l = 0
d = {'A', 'E', 'I', 'O', 'U', 'Y'}
for i in range(len(s)):
	if s[i] in d:
		l = max(l, m)
		m = 1
	else:
		m += 1
l = max(l, m)
if l == 0:
	print(len(s) + 1)
else:
	print(l)


s = input().lower()
m = 0
count = 0
for c in s:
	if c in ['a', 'e', 'i', 'o', 'u', 'y']:
		count = 0
	else:
		count += 1
		m = max(m, count)
print(m + 1)


a = str(input())
a = list(a)
kmax = 0
vowels = ['A', 'E', 'I', 'O', 'U', 'Y']
f = []
a = ['A'] + a + ['A']
for i in range(len(a)):
	if vowels.count(a[i]) > 0:
		f.append(i)
for i in range(len(f) - 1):
	k = f[i + 1] - f[i]
	if k > kmax:
		kmax = k
print(kmax)


s = input()
count = 0
k = len(s)
a = [0]
b = list()
for i in s:
	if i == 'A' or i == 'E' or i == 'I' or (i == 'U') or (i == 'Y') or (i == 'O'):
		a.append(count + 1)
	count = count + 1
a.append(k + 1)
k = len(a)
for i in range(1, k):
	b.append(a[i] - a[i - 1])
print(max(b))


import sys
input = sys.stdin.readline
s = input()[:-1]
n = len(s)
samohlasky = ['A', 'E', 'I', 'O', 'U', 'Y']
pos = []
for i in range(n):
	if s[i] in samohlasky:
		pos.append(i)
if len(pos) == 0:
	print(n + 1)
	sys.exit()
pos.append(n)
diff = [pos[0] + 1]
for i in range(len(pos) - 1):
	diff.append(abs(pos[i] - pos[i + 1]))
print(max(diff))


s = input().strip()
vowels = ['A', 'E', 'I', 'O', 'U', 'Y']
idx = -1
maxDist = 1
for (i, c) in enumerate(s):
	if c in vowels:
		maxDist = max(maxDist, i - idx)
		idx = i
maxDist = max(maxDist, len(s) - idx)
print(maxDist)


s = input()
T = [0]
L = set(['A', 'E', 'I', 'O', 'U', 'Y'])
for x in range(len(s)):
	if s[x] in L:
		T.append(x + 1)
T.append(len(s) + 1)
m = -1
for x in range(len(T)):
	m = max(m, T[x] - T[max(0, x - 1)])
print(m)


path = input()
i = 0
maxi = 0
path += 'A'
for car in path:
	i += 1
	maxi = max(maxi, i)
	if car in 'AEIOUY':
		i = 0
print(maxi)


s = input()
t = ['A', 'E', 'I', 'O', 'U', 'Y']
cur = -1
n = len(s)
m = 0
for i in range(n):
	if s[i] in t:
		m = max(m, i - cur)
		cur = i
m = max(n - cur, m)
print(m)


text = input()
alphabet = 'AEIOUY'
maxLength = 0
lenght = 0
for i in text:
	if i not in alphabet:
		lenght += 1
	else:
		lenght += 1
		if lenght > maxLength:
			maxLength = lenght
		lenght = 0
lenght += 1
if lenght > maxLength:
	maxLength = lenght
lenght = 0
print(maxLength)


s = input()
maximum = 0
counter = 0
v = ['A', 'E', 'I', 'O', 'U', 'Y']
if 'A' not in s and 'E' not in s and ('I' not in s) and ('O' not in s) and ('U' not in s) and ('Y' not in s):
	print(len(s) + 1)
else:
	for num in s:
		counter += 1
		if num in v:
			if counter > maximum:
				maximum = counter
			counter = 0
	print(max(maximum, counter + 1))


s = input()
s = 'A' + s + 'A'
m = 0
c = 0
for ch in s:
	if ch in 'AEIOUY':
		m = max(m, c)
		c = 0
	else:
		c += 1
print(m + 1)


s = input()
a = ['A', 'E', 'Y', 'O', 'I', 'U']
ans = 1
buf = 1
for x in s:
	if x in a:
		ans = max(ans, buf)
		buf = 1
	else:
		buf += 1
if buf > 0:
	ans = max(ans, buf)
print(ans)


x = input()
max = 0
start = 1
for i in x:
	if i == 'A' or i == 'U' or i == 'I' or (i == 'E') or (i == 'O') or (i == 'Y'):
		if start > max:
			max = start
		start = 1
	else:
		start += 1
if max < start:
	print(start)
else:
	print(max)


t = input()
cnt = 0
max1 = 0
t1 = 'AEIOUY'
for i in t:
	cnt = cnt + 1
	if i in t1:
		if cnt > max1:
			max1 = cnt
		cnt = 0
cnt = cnt + 1
if cnt > max1:
	max1 = cnt
print(max1)


string = input()
jumps = []
init = 0
string = '*' + string + 'A'
if any((t == 'A' or t == 'E' or t == 'I' or (t == 'O') or (t == 'U') or (t == 'Y') for t in string)):
	if len(string) == 1:
		print(1)
	else:
		for i in range(len(string)):
			if string[i] == 'A' or string[i] == 'E' or string[i] == 'I' or (string[i] == 'O') or (string[i] == 'U') or (string[i] == 'Y'):
				diff = i - init
				init = i
				jumps.extend([abs(diff)])
	print(max(jumps))
else:
	print(len(string))


str = str(input())
list = list(str)
res = 0
max = 0
for i in list:
	if i != 'A' and i != 'E' and (i != 'I') and (i != 'O') and (i != 'U') and (i != 'Y'):
		res += 1
		if res > max:
			max = res
	else:
		res = 0
print(max + 1)


s = input()
k = 1
max_k = 0
for i in s:
	if i in 'AEIOUY':
		max_k = max(max_k, k)
		k = 1
	else:
		k += 1
max_k = max(max_k, k)
print(max_k)


s = input()
index = [-1]
for i in range(len(s)):
	if s[i] in 'AEIOUY':
		index.append(i)
index.append(len(s))
g = -2
for i in range(1, len(index)):
	if index[i] - index[i - 1] > g:
		g = index[i] - index[i - 1]
print(g)


n = input()
c = []
t = 0
vowels = 'AEIOUY'
k = False
try:
	for i in range(len(n)):
		if n[i] in vowels:
			c.append(i + 1 - t)
			t = i + 1
			k = True
	if k == True:
		c.append(len(n) - (t - 1))
		print(max(c))
	else:
		print(len(n) + 1)
except:
	print(len(n) + 1)


word = list(input())
letter = ['A', 'E', 'I', 'O', 'U', 'Y']
for i in range(len(word)):
	for j in range(len(letter)):
		if word[i] == letter[j]:
			word[i] = '0'
c = 1
d = 0
for i in range(len(word)):
	if word[i] != '0' and word[i] != word[-1]:
		c += 1
	elif word[i] != '0' and word[i] == word[-1]:
		c += 1
		if d < c:
			d = c
	else:
		if d < c:
			d = c
		c = 1
print(d)


str = input()
str += '$'
ans = 0
vowels = ['A', 'E', 'I', 'O', 'U', 'Y', '$']
cur = 0
for i in range(1, len(str) + 1):
	if str[i - 1] in vowels:
		ans = max(ans, i - cur)
		cur = i
print(ans)


def isVowel(c):
	check = 'AEIOUY'
	return check.find(c) >= 0
s = input()
res = 1
dist = 1
for w in s:
	if isVowel(w):
		res = max(res, dist)
		dist = 1
	else:
		dist += 1
res = max(res, dist)
print(res)


s = list(input())
n = len(s)
m = 0
l = ['A', 'E', 'I', 'O', 'U', 'Y']
c = 0
for i in range(n):
	if s[i] not in l:
		c += 1
		if c > m:
			m = c
	else:
		c = 0
print(m + 1)


s = input()
for ch in 'AEIOUY':
	s = s.replace(ch, ' ')
print((max(map(len, s.split())) if s.split() else 0) + 1)


indices = [0]
s = input().strip()
n = len(s)
for i in range(len(s)):
	if s[i] in 'AEIOUY':
		indices.append(i + 1)
distances = [indices[i] - indices[i - 1] for i in range(1, len(indices))]
distances.append(n - indices[-1] + 1)
if len(distances) == 1:
	print(n + 1)
else:
	print(max(distances))


y = 'AEIOUY'
x = input()
(mn, pos) = (0, -1)
ln = len(x)
for i in range(ln):
	if x[i] in y:
		mn = max(mn, i - pos)
		pos = i
print(max(mn, ln - pos))


string = input()
a = ('A', 'E', 'I', 'O', 'U', 'Y')
maximum = 1
i = 1
for c in string:
	if c not in a:
		i += 1
	else:
		if i > maximum:
			maximum = i
		i = 1
if i > maximum:
	maximum = i
print(maximum)


s = input()
j = 0
distance = [0 for x in range(len(s))]
m = 0
for i in range(0, len(s)):
	if s[i] in 'AEIOUY':
		j += 1
	else:
		distance[j] += 1
		m = max(distance[j], m)
print(m + 1)


a = input()
Max = 1
count = 1
for i in a:
	if i != 'A' and i != 'E' and (i != 'O') and (i != 'U') and (i != 'Y') and (i != 'I'):
		count = count + 1
		if count > Max:
			Max = count
	else:
		count = 1
print(Max)


s = input()
k = 0
m = 1
g = {'A', 'E', 'I', 'O', 'Y', 'U'}
for i in s:
	k += 1
	if i in g:
		if k > m:
			m = k
		k = 0
if k >= m:
	print(k + 1)
else:
	print(m)


s = input()
m = 0
tmp = 0
for i in range(len(s)):
	if s[i] in 'AEIOUY':
		if m < tmp:
			m = tmp
		tmp = 0
	else:
		tmp += 1
	if i == len(s) - 1:
		if m < tmp:
			m = tmp
			tmp = 0
print(m + 1)


gl = ['A', 'E', 'I', 'O', 'U', 'Y']
s = input()
max = 0
b = True
maxi = -1
for i in range(0, len(s)):
	if s[i] in gl:
		if i - maxi > max:
			max = i - maxi
			b = False
		maxi = i
if i + 1 - maxi > max:
	max = i + 1 - maxi
if max == 0:
	print(len(s) + 1)
else:
	print(max)


vowels = ['A', 'E', 'I', 'O', 'U', 'Y']
myString = input()
myList = list()
myJumps = list()
for x in range(0, len(myString), 1):
	myList.append(myString[x])
temp = 0
for element in myList:
	if element in vowels:
		myJumps.append(temp + 1)
		temp = 0
	else:
		temp += 1
	myJumps.append(temp + 1)
print(max(myJumps))


def vowel(s):
	return s == 'a' or s == 'e' or s == 'i' or (s == 'o') or (s == 'u') or (s == 'y')
s = input().lower()
a = []
for i in range(len(s)):
	if vowel(s[i]):
		a.append(i)
if a == []:
	print(len(s) + 1)
else:
	b = [a[0] + 1]
	for i in range(len(a) - 1):
		b.append(a[i + 1] - a[i])
	b.append(len(s) - a[-1])
	print(max(b))


a = 'AEIOUY'
n = input()
b = [0]
c = 1
flag = 0
for i in range(len(n)):
	if n[i] not in a:
		c += 1
	else:
		b.append(c)
		c = 1
print(max(max(b), c))


xyz = list(input())
list1 = [0]
list2 = ['A', 'E', 'I', 'O', 'U', 'Y']
for i in range(0, len(xyz)):
	try:
		if list2.count(xyz[i]) is 1:
			list1.append(i + 1)
	except:
		pass
list1.append(len(xyz) + 1)
min = 0
for i in range(1, len(list1)):
	if list1[i] - list1[i - 1] > min:
		min = list1[i] - list1[i - 1]
print(min)


vowels = 'AEIOUY'
jump = 'A' + input() + 'A'
le = 1
st = 1
for i in jump[1:]:
	if i not in vowels:
		st += 1
		le = max(st, le)
	else:
		st = 1
print(le)


inp = input()
lst = [0] * len(inp)
for i in range(len(inp)):
	if inp[i] in 'AEIUOY':
		lst[i] = i + 1
jumps = []
last = 0
for i in range(len(lst)):
	if lst[i] != 0:
		jump = lst[i] - last
		jumps.append(jump)
		last = lst[i]
jumps.append(len(inp) - last + 1)
if jumps == []:
	print(len(inp) + 1)
else:
	print(max(jumps))


a = ['A'] + list(input()) + ['A']
(b, c) = ([], 0)
for x in range(len(a)):
	if a[x] in 'AIUEOY':
		c += 1
		b.append(c)
		c = 0
	else:
		c += 1
print(max(b))


s = input()
n = len(s)
i = 0
j = -1
x = 1
c = 0
v = ['a', 'e', 'i', 'o', 'u', 'y']
while i < n:
	if s[i].lower() in v:
		x = max(x, i - j)
		j = i
	else:
		c += 1
	i += 1
if n - j > x:
	x = n - j
if c == n:
	print(n + 1)
else:
	print(x)


def stroka(s):
	s += 'A'
	n = len(s) + 1
	(pos, count) = (-1, 0)
	for i in range(n - 1):
		if s[i] == 'A' or s[i] == 'E' or s[i] == 'I' or (s[i] == 'O') or (s[i] == 'U') or (s[i] == 'Y'):
			if i - pos > count:
				count = i - pos
			pos = i
	return count
print(stroka(input()))


s = list(input())
VOWELS = 'AEIOUY'
res = 0
tmp = 0
for i in s:
	tmp += 1
	if i in VOWELS:
		if res < tmp:
			res = tmp
		tmp = 0
tmp += 1
if res < tmp:
	res = tmp
tmp = 0
print(res)


n = input()
a = 0
mx = 0
for i in range(len(n)):
	if n[i] == 'A' or n[i] == 'E' or n[i] == 'I' or (n[i] == 'O') or (n[i] == 'U') or (n[i] == 'Y'):
		a = a + 1
		mx = max(mx, a)
		a = 0
	else:
		a = a + 1
mx = max(mx, a + 1)
print(mx)


a = 'A' + input() + 'A'
vowels = ['A', 'E', 'I', 'O', 'U', 'Y']
temp = 0
counter = 0
jumps = []
for i in a:
	counter += 1
	if i in vowels:
		jumps.append(counter)
		counter = 0
print(max(jumps))


n = input()
(mx, cn) = (0, 1)
for i in range(len(n)):
	if n[i] in 'AEIOUY':
		mx = max(mx, cn)
		cn = 1
		continue
	else:
		cn += 1
mx = max(mx, cn)
print(mx)


s = input()
mx = 0
last = -1
vowels = list('AEIOUY')
for i in range(len(s)):
	if s[i] in vowels:
		mx = max(mx, i - last)
		last = i
mx = max(mx, i - last + 1)
print(mx)


s = input()
a = 1
b = 0
c = 0
for i in s:
	if i in 'AEIOUY':
		c = max(c, a - b)
		b = a
	a += 1
c = max(c, a - b)
print(c)


s = str(input())
(res, last) = (0, -1)
for i in range(len(s)):
	if s[i] in 'AEIOUY':
		res = max(res, i - last)
		last = i
if last == -1:
	print(len(s) + 1)
else:
	print(max(res, len(s) - last))


s = input()
i = 0
ans = 0
n = len(s)
while i < n:
	if s[i] == 'A' or s[i] == 'E' or s[i] == 'I' or (s[i] == 'O') or (s[i] == 'U') or (s[i] == 'Y'):
		l = 1
		i += 1
		while i < n and s[i] != 'A' and (s[i] != 'E') and (s[i] != 'I') and (s[i] != 'O') and (s[i] != 'U') and (s[i] != 'Y'):
			i += 1
			l += 1
		ans = max(ans, l)
	else:
		l = 1
		while i < n and s[i] != 'A' and (s[i] != 'E') and (s[i] != 'I') and (s[i] != 'O') and (s[i] != 'U') and (s[i] != 'Y'):
			i += 1
			l += 1
		ans = max(ans, l)
print(ans)


os = 'AEIOUY'
cs = input() + 'A'
ans = 1
Last = -1
for c in range(len(cs)):
	if os.count(cs[c]) > 0:
		ans = max(ans, c - Last)
		Last = c
print(ans)


s = list(input()) + ['A']
ans = 1
k = 0
l = ['A', 'E', 'I', 'O', 'U', 'Y']
for x in s:
	k += 1
	if ans < k:
		ans = k
	if x in l:
		k = 0
print(ans)


s = input()
glas = ['A', 'E', 'I', 'O', 'U', 'Y']
prev = -1
result = 0
for i in range(len(s)):
	if s[i] in glas:
		result = max(i - prev, result)
		prev = i
result = max(i - prev + 1, result)
print(result)


s = input()
v = ['A', 'E', 'I', 'O', 'U', 'Y']
c = 1
m = 0
for i in s:
	if i in v:
		m = max(m, c)
		c = 1
	else:
		c += 1
m = max(m, c)
if m == 0:
	print(len(s) + 1)
else:
	print(m)


def Vowels(d):
	if d == 'A' or d == 'E' or d == 'I' or (d == 'O') or (d == 'U') or (d == 'Y'):
		return False
	else:
		return True
hopp = list(map(str, input()))
flag = 1
mas = []
for i in range(len(hopp)):
	d = hopp[i]
	if Vowels(d):
		flag += 1
		mas.append(flag)
	else:
		flag = 1
if mas == []:
	print(1)
else:
	print(max(mas))


__author__ = 'Think'
s = input() + 'A'
current = -1
m = 0
for i in range(len(s)):
	if s[i] in ['A', 'E', 'I', 'O', 'U', 'Y']:
		m = max(m, i - current)
		current = i
print(m)


inputString = input() + 'A'
step = 1
requireStep = 0
volwelSet = {'A', 'E', 'I', 'O', 'U', 'Y'}
for c in inputString:
	step = 1 if c in volwelSet else step + 1
	requireStep = step if step > requireStep else requireStep
print(requireStep)


s = input()
s += 'A'
c = 0
fa = 0
count = 1
while c < len(s):
	if s[c] == 'A' or s[c] == 'E' or s[c] == 'I' or (s[c] == 'O') or (s[c] == 'U') or (s[c] == 'Y'):
		if fa < count:
			fa = count
		count = 1
	else:
		count += 1
	c += 1
print(fa)


letters = input()
letters = list(letters)
letters.insert(0, 'A')
letters.append('A')
count = 0
max_jump = 0
for i in range(len(letters)):
	ltr = letters[i]
	if ltr == 'A' or ltr == 'E' or ltr == 'I' or (ltr == 'O') or (ltr == 'U') or (ltr == 'Y'):
		count += 1
		if count > max_jump:
			max_jump = count
			count = 0
		else:
			count = 0
	else:
		count += 1
print(max_jump)


s = input()
a = 'AEUYEOI'
pos = [0]
for i in range(len(s)):
	if s[i] in a:
		pos.append(i + 1)
pos.append(len(s) + 1)
max_ = pos[1] - pos[0]
for i in range(2, len(pos)):
	max_ = max(max_, pos[i] - pos[i - 1])
print(max_)


s = input()
x = c = 1
for (i, ch) in enumerate(s):
	if ch not in 'AEIOUY':
		c += 1
	else:
		x = max(c, x)
		c = 1
print(max(c, x))


stroka = input()
k = 0
maxi = 0
for i in range(len(stroka)):
	if stroka[i] == 'A' or stroka[i] == 'E' or stroka[i] == 'I' or (stroka[i] == 'O') or (stroka[i] == 'U') or (stroka[i] == 'Y'):
		if maxi < k:
			maxi = k
		k = 0
	else:
		k += 1
		if maxi < k:
			maxi = k
print(maxi + 1)


X = list(input())
Y = -1
Z = 0
for (H, I) in enumerate(X):
	if I == 'A' or I == 'E' or I == 'I' or (I == 'O') or (I == 'U') or (I == 'Y'):
		Z = max(Z, H - Y)
		Y = H
Z = max(Z, len(X) - Y)
print(Z)


s_v = set()
s_v.add('A')
s_v.add('E')
s_v.add('I')
s_v.add('O')
s_v.add('U')
s_v.add('Y')
s = input()
p = -1
m = -1
for i in range(len(s)):
	if s[i] in s_v:
		m = max(m, i - p)
		p = i
i += 1
m = max(m, i - p)
print(m)


s = str(input())
x = ['A', 'E', 'I', 'O', 'U', 'Y']
i = 0
ans = 0
while i < len(s):
	c = 0
	if s[i] not in x:
		while i < len(s) and s[i] not in x:
			c = c + 1
			i = i + 1
		ans = max(ans, c)
	i = i + 1
print(ans + 1)


def main():
	string = 'Z' + input() + 'A'
	n = len(string)
	vowels = 'AEIOUY'
	max_length = 0
	index = 0
	while index < n - 1:
		next_index = next((i for i in range(index + 1, n) if string[i] in vowels))
		max_length = max(max_length, next_index - index)
		index = next_index
	print(max_length)
main()


line = input() + 'A'
vowels = 'AEIOUY'
start = -1
limit = 1
for i in range(len(line)):
	if line[i] in vowels:
		if i - start > limit:
			limit = i - start
		start = i
print(limit)


s = input()
l = [-1]
for i in range(len(s)):
	if s[i] == 'A' or s[i] == 'E' or s[i] == 'I' or (s[i] == 'O') or (s[i] == 'U') or (s[i] == 'Y'):
		l.append(i)
l.append(len(s))
m = l[1] - l[0]
for i in range(2, len(l)):
	x = l[i] - l[i - 1]
	if x > m:
		m = x
print(m)


s = input()
m = 1
maxx = 1
b = ['A', 'E', 'I', 'O', 'U', 'Y']
for z in s:
	if z in b:
		m = 1
	else:
		m += 1
	if m > maxx:
		maxx = m
print(maxx)


from queue import PriorityQueue
fmap = lambda f, l: list(map(f, l))
parse_int = lambda : fmap(int, input().split())
(pri, cur) = (1, 1)
son = 'AEIOYU'
for let in input().strip() + 'O':
	if let in son:
		cur = 1
	else:
		cur += 1
		pri = max(cur, pri)
print(pri)


n = input()
l = []
cnt = 0
ma = 0
for i in range(len(n)):
	if n[i] not in 'AEIOUY':
		cnt += 1
	else:
		if cnt >= ma:
			ma = cnt
		cnt = 0
print(max(cnt + 1, ma + 1))


s = input()
curr = -1
vow = ['A', 'E', 'I', 'O', 'U', 'Y']
mn = 0
i = 0
l = len(s)
while i < l:
	if s[i] in vow:
		if i - curr > mn:
			mn = i - curr
		curr = i
	i += 1
mn = max(mn, l - curr)
print(mn)


s = str(input())
gl = ['A', 'E', 'I', 'O', 'U', 'Y']
pr = 0
cpr = 0
for i in s:
	cpr += 1
	if i in gl:
		if pr < cpr:
			pr = cpr
		cpr = 0
if cpr != 0 and pr != 0:
	if pr <= cpr:
		pr = cpr + 1
if pr == 0:
	pr = len(s) + 1
print(pr)


def main():
	s = input()
	print(solver(s))

def solver(s):
	maxjump = 1
	position = -1
	for i in range(len(s)):
		if s[i] in ['A', 'E', 'I', 'O', 'U', 'Y']:
			jump = i - position
			position = i
			if jump > maxjump:
				maxjump = jump
	lastjump = len(s) - position
	if lastjump > maxjump:
		maxjump = lastjump
	return maxjump
main()


n = input()
n = n + 'A'
cnt = 1
l = []
for t in n:
	if t == 'A' or t == 'E' or t == 'I' or (t == 'O') or (t == 'U') or (t == 'Y'):
		l.append(cnt)
		cnt = 1
	else:
		cnt = cnt + 1
print(max(l))


girdi = input() + 'A'
cekirge = 1
cekirgemax = 0
pezo = 'AEOIUY'
for i in girdi:
	if i in pezo:
		if cekirge > cekirgemax:
			cekirgemax = cekirge
		cekirge = 1
	else:
		cekirge += 1
print(cekirgemax)


s = str(input())
v = ['A', 'E', 'I', 'O', 'U', 'Y']
currPos = -1
m = 0
for i in range(len(s)):
	if s[i] in v:
		d = i - currPos
		currPos = i
		if d > m:
			m = d
d = len(s) - currPos
if d > m:
	m = d
print(m)


s = input()
k = x = 0
for i in range(len(s)):
	if s[i] != 'A' and s[i] != 'E' and (s[i] != 'I') and (s[i] != 'O') and (s[i] != 'U') and (s[i] != 'Y'):
		k += 1
	else:
		k = 0
	if x < k:
		x = k
print(x + 1)


S = input()
num = 1
tmp = 1
for i in S:
	if i not in ['A', 'I', 'U', 'E', 'O', 'Y']:
		tmp += 1
	else:
		num = max(num, tmp)
		tmp = 1
num = max(num, tmp)
print(num)


l = list(input())
a = ['A', 'E', 'I', 'O', 'U', 'Y']
z = []
l.insert(0, 'A')
l.append('A')
(c, d) = (0, 0)
for i in range(1, len(l)):
	if l[i] in a:
		c = i
		z.append(abs(c - d))
		d = i
print(max(z))


import sys
s = sys.stdin.readline()[:-1]
vowels = list('AEIOUY')
jump = 0
now = -1
for (i, c) in enumerate(s):
	if c in vowels:
		dist = i - now
		jump = dist if dist > jump else jump
		now = i
dist = len(s) - now
jump = dist if dist > jump else jump
sys.stdout.write(str(jump))


a = input()
l = []
n = len(a)
if len(a) == 1:
	if a == 'A' or a == 'E' or a == 'I' or (a == 'O') or (a == 'U') or (a == 'Y'):
		print(1)
	else:
		print(2)
else:
	for i in range(n):
		if a[i] == 'A' or a[i] == 'E' or a[i] == 'I' or (a[i] == 'O') or (a[i] == 'U') or (a[i] == 'Y'):
			l.append(i)
	if len(l) == 1:
		print(max(l[0] + 1, n - l[0]))
	elif len(l) == 0:
		print(n + 1)
	else:
		m = 1
		for i in range(len(l) - 1):
			m = max(l[i + 1] - l[i], m)
		m = max(l[0] + 1, m)
		m = max(n - l[len(l) - 1], m)
		print(m)


x = input()
jump = int(0)
temp = int(0)
for el in x:
	if el == 'A' or el == 'E' or el == 'I' or (el == 'O') or (el == 'U') or (el == 'Y'):
		jump = jump + 1
		if jump > temp:
			temp = jump
		jump = 0
	else:
		jump = jump + 1
jump = jump + 1
if jump > temp:
	temp = jump
print(temp)


str = input()
vowels = ['A', 'E', 'I', 'O', 'U', 'Y']
mj = init_pos = 0
for i in range(len(str)):
	if str[i] in vowels:
		f = i + 1 - init_pos
		init_pos = i + 1
		if f > mj:
			mj = f
rm = len(str) - init_pos + 1
if rm > mj:
	print(rm)
else:
	print(mj)


vowels = ['A', 'E', 'I', 'O', 'U', 'Y']
line = input()
newline = ''
for letter in line:
	if letter in vowels:
		newline += '#'
	else:
		newline += letter
max_len = 0
for l in newline.split('#'):
	max_len = max(max_len, len(l))
print(max_len + 1)


s = input()
vowels = {'A', 'E', 'I', 'O', 'U', 'Y'}
prev = -1
max_step = 0
if s[len(s) - 1] not in vowels:
	s += 'A'
for i in range(len(s)):
	if s[i] in vowels:
		step = i - prev
		prev = i
		if step > max_step:
			max_step = step
print(max_step)


s = input()
dis = 1
prev = -1
for i in range(len(s)):
	if s[i] in 'AEIOUY':
		dis = max(dis, i - prev)
		prev = i
dis = max(dis, len(s) - prev)
print(dis)


a = 'A' + input() + 'A'
(ans, counter) = (0, -1)
for i in a:
	counter += 1
	if i in 'AEIOUY':
		ans = max(ans, counter)
		counter = 0
print([1, ans][ans != 0])


my = input()
vavel = ['A', 'E', 'I', 'O', 'U', 'Y']
index = [-1]
ans = []
for i in range(len(my)):
	if my[i] in vavel:
		index.append(i)
index.append(len(my))
for i in range(len(index) - 1):
	ans.append(index[i + 1] - index[i])
if ans == []:
	ans.append(0)
print(max(ans))


a = input()
p = -1
b = ['A', 'E', 'I', 'O', 'U', 'Y']
ans = 0
for i in range(len(a)):
	if a[i] in b:
		if p == -1:
			ans = i + 1
			p = i
		else:
			ans = max(ans, i - p)
			p = i
ans = max(ans, len(a) - p)
print(ans)


a = input()
vowels = 'AEIOUY'
count = 1
temp = 1
for i in range(len(a)):
	if a[i] in vowels:
		temp = 1
	else:
		temp += 1
	count = max(count, temp)
print(count)


s = input()
l = ['A', 'E', 'I', 'O', 'U', 'Y']
(ans, t, lenn) = (0, -1, len(s))
for i in range(lenn):
	if s[i] in l:
		ans = max(ans, i - t)
		t = i
ans = max(ans, lenn - t)
print(ans)


vowels = set(['A', 'E', 'I', 'O', 'U', 'Y'])
s = input()
max_a = 0
b = 0
for i in range(len(s)):
	b += 1
	if s[i] in vowels:
		if b > max_a:
			max_a = b
		b = 0
if not s[-1] in vowels:
	b += 1
print(max(b, max_a))


s = input()
v = ['A', 'E', 'I', 'O', 'U', 'Y']
l = [0]
for i in range(len(s)):
	if s[i] in v:
		l.append(i + 1)
l.append(len(s) + 1)
d = [l[x + 1] - l[x] for x in range(len(l) - 1)]
print(max(d))


field = 'A' + input() + 'A'
letters = ['A', 'E', 'I', 'O', 'U', 'Y']
ans = 1
last_let = 0
for i in range(len(field)):
	let = field[i]
	if let in letters:
		ans = max(ans, i - last_let)
		last_let = i
print(ans)


import sys
import math
import bisect

def main():
	s = input()
	n = len(s)
	max_val = 0
	last = -1
	for i in range(n):
		if s[i] in 'AEIOUY':
			val = i - last
			max_val = max(max_val, val)
			last = i
	max_val = max(max_val, n - last)
	print(max_val)
main()


3
vowels = ['A', 'E', 'I', 'O', 'U', 'Y']
s = 'A' + input() + 'A'
arr = [i for i in range(len(s)) if s[i] in vowels]
diffs = [arr[i + 1] - arr[i] for i in range(len(arr) - 1)]
print(max(diffs))


s = input()
k = -1
m = 0
for i in range(len(s)):
	if s[i] in 'AEIOUY':
		if i - k > m:
			m = i - k
		k = i
if len(s) - k > m:
	m = len(s) - k
print(m)


s = input()
glas = 'AEIOUY'
max = 1
counter = 1
for c in s:
	if c not in glas:
		counter += 1
	else:
		if counter > max:
			max = counter
		counter = 1
if counter > max:
	max = counter
print(max)


vowels = ['A', 'E', 'I', 'O', 'U', 'Y']
s = input()
if not any((vowel in s for vowel in vowels)):
	print(len(s) + 1)
else:
	for k in range(1, len(s) + 1):
		sure = True
		for end in range(k - 1, len(s)):
			beg = end - k + 1
			sub = s[beg:end + 1]
			sure = any((vowel in sub for vowel in vowels))
			if not sure:
				break
		if sure:
			print(k)
			break


ch = input()
a = 0
S = 1
for i in range(len(ch)):
	if ch[i] in ['A', 'E', 'U', 'I', 'O', 'Y']:
		if S > a:
			a = S
		S = 1
	else:
		S += 1
if S > a:
	a = S
print(a)


string = input()
jump = 0
temp = 0
for i in string.upper():
	if i == 'A' or i == 'E' or i == 'I' or (i == 'O') or (i == 'U') or (i == 'Y'):
		jump += 1
		if jump > temp:
			temp = jump
		jump = 0
	else:
		jump += 1
jump += 1
if jump > temp:
	temp = jump
print(temp)


(s, count, Max) = (input(), 1, 0)
for i in range(len(s)):
	if s[i] in 'AEIOUY':
		(Max, count) = (max(Max, count), 1)
	else:
		count += 1
print(max(Max, count))


word_input = input().lower()
word_list = []
for x in word_input:
	word_list.append(x)
largest = []
start = 1
vowel = ['a', 'e', 'i', 'o', 'u', 'y']
for x in word_list:
	if x not in vowel:
		start += 1
		largest.append(start)
	elif x in vowel:
		largest.append(start)
		start = 1
	else:
		start += 1
		largest.append(start)
maximum = 0
for x in largest:
	if x > maximum:
		maximum = x
print(maximum)


inp = input()
s = list(inp)
l = []
max = 0
s.append('A')
for i in range(0, len(s), 1):
	if s[i] == 'A' or s[i] == 'E' or s[i] == 'I' or (s[i] == 'O') or (s[i] == 'U') or (s[i] == 'Y'):
		l.append(i + 1)
max = l[0]
for j in range(len(l)):
	if j + 1 == len(l):
		break
	d = l[j + 1] - l[j]
	if d > max:
		max = d
print(max)


s = ['B'] + list(input())
keys = [0] + [key for (key, data) in enumerate(s) if data in 'AEIOUY']
if not keys:
	print(len(s))
else:
	keys.append(len(s))
	print(max([keys[i + 1] - keys[i] for i in range(len(keys) - 1)]))


import sys
s = sys.stdin.readline()
cnt = 0
res = 0
for i in s[:-1]:
	if i != 'A' and i != 'E' and (i != 'I') and (i != 'O') and (i != 'U') and (i != 'Y'):
		cnt += 1
	else:
		if cnt > res:
			res = cnt
		cnt = 0
if cnt > res:
	res = cnt
print(res + 1)


V = ('A', 'E', 'I', 'O', 'Y', 'U')
s = input()
j = -1
max = 0
for i in range(len(s)):
	if s[i] in V:
		if i - j > max:
			max = i - j
		j = i
	if i == len(s) - 1:
		if len(s) - j > max:
			max = len(s) - j
print(max)


a = input()
b = 'AEIOUY'
l = [-1]
j = m = 0
for i in a:
	if i in b:
		l.append(a.index(i, j))
		j = a.index(i, j) + 1
		if j >= len(a):
			exit
l.append(len(a))
for i in range(len(l) - 1):
	m = max(l[i + 1] - l[i], m)
print(m)


a = input()
l = []
t = 0
for i in a:
	if i == 'A' or i == 'E' or i == 'I' or (i == 'O') or (i == 'U') or (i == 'Y'):
		t += 1
		l += [t]
		t = 0
	else:
		t += 1
else:
	l += [t + 1]
	print(max(l))


S = input()
vowels = 'AEIOUY'
S += 'A'
prev_pos = -1
max_jump = 0
for (i, ch) in enumerate(S):
	if ch in vowels:
		next_pos = i
		max_jump = max(max_jump, next_pos - prev_pos)
		prev_pos = next_pos
print(max_jump)


A = {'A', 'E', 'I', 'O', 'U', 'Y'}
stroka = input()
stroka = ' ' + stroka
res = 0
first = 0
for elem in range(len(stroka)):
	if stroka[elem] in A:
		if res < len(stroka[first:elem]):
			res = len(stroka[first:elem])
		first = elem
if len(stroka[first:len(stroka)]) > res:
	res = len(stroka[first:len(stroka)])
print(res)


s = input()
v = ['A', 'E', 'I', 'O', 'U', 'Y']
i = -1
m = 0
while i < len(s):
	prev = i
	j = prev + 1
	while j < len(s) and s[j] not in v:
		j += 1
	if m < j - prev:
		m = j - prev
	prev = j
	i = prev
print(m)


s2 = input()
s3 = []
w = 0
for i in range(len(s2)):
	if s2[i] == 'A':
		s3.append(w)
		w = 0
		continue
	elif s2[i] == 'O':
		s3.append(w)
		w = 0
		continue
	elif s2[i] == 'U':
		s3.append(w)
		w = 0
		continue
	elif s2[i] == 'E':
		s3.append(w)
		w = 0
		continue
	elif s2[i] == 'Y':
		s3.append(w)
		w = 0
		continue
	elif s2[i] == 'I':
		s3.append(w)
		w = 0
		continue
	else:
		w += 1
		s3.append(w)
s3.sort()
print(int(s3[-1]) + 1)


import re

def grasshoper_and_the_string():
	data = input()
	l = sorted(re.findall('[^AEIOUYaeiouy]+', data), key=len, reverse=True)
	if len(l):
		return len(l[0]) + 1
	else:
		return 1
print(grasshoper_and_the_string())


l = list(input())
g1 = 0
s = len(l)
g2 = s + 1
c = 0
p = ['A', 'E', 'I', 'O', 'U', 'Y']
for i in range(s):
	if i == s - 1 and l[i] not in p:
		t = g2 - g1
		if c < t:
			c = t
	elif l[i] in p:
		t = i + 1 - g1
		g1 = i + 1
		if c < t:
			c = t
print(c)


a = input()
ability = 1
b = []
for i in range(len(a)):
	if a[i] == 'A':
		b.append(ability)
		ability = 1
	elif a[i] == 'E':
		b.append(ability)
		ability = 1
	elif a[i] == 'I':
		b.append(ability)
		ability = 1
	elif a[i] == 'O':
		b.append(ability)
		ability = 1
	elif a[i] == 'U':
		b.append(ability)
		ability = 1
	elif a[i] == 'Y':
		b.append(ability)
		ability = 1
	else:
		ability += 1
b.append(ability)
print(max(b))


s = input()
i = -1
mx = 1
for j in range(len(s)):
	if s[j] in 'AEIOUY':
		mx = max(j - i, mx)
		i = j
mx = max(len(s) - i, mx)
print(mx)


n = input()
m = []
c = 0
for i in n:
	if i == 'A' or i == 'E' or i == 'I' or (i == 'O') or (i == 'U') or (i == 'Y'):
		m.append(c)
		c = 0
	else:
		c = c + 1
m.append(c)
print(max(m) + 1)


s = input()
maxx = 0
test = ['A', 'E', 'I', 'O', 'U', 'Y']
v = 0
for i in range(len(s)):
	if s[i] not in test:
		v += 1
	else:
		if v > maxx:
			maxx = v
		v = 0
else:
	if v > maxx:
		maxx = v
print(maxx + 1)


s = input()
l = len(s)
max = 0
pre = -1
aim = l
for i in range(0, l):
	if s[i] == 'A' or s[i] == 'E' or s[i] == 'I' or (s[i] == 'O') or (s[i] == 'U') or (s[i] == 'Y'):
		temp = i - pre
		pre = i
		if temp > max:
			max = temp
temp = aim - pre
if temp > max:
	max = temp
print(max)


s = input()
start = 0
jump = 0
max = 0
for i in range(len(s)):
	jump += 1
	if s[i] == 'A' or s[i] == 'E' or s[i] == 'I' or (s[i] == 'O') or (s[i] == 'U') or (s[i] == 'Y'):
		if jump > max:
			max = jump
		jump = 0
jump += 1
if jump > max:
	max = jump
print(max)


c = 1
m = 1
for i in list(input()):
	if i in 'AEIOUY':
		if c > m:
			m = c
		c = 0
	c += 1
if c > m:
	m = c
print(m)


def jump(s):
	abi = 0
	j = 0
	for x in range(len(s)):
		if s[x] == 'A' or s[x] == 'E' or s[x] == 'I' or (s[x] == 'O') or (s[x] == 'U') or (s[x] == 'Y'):
			j += 1
			if j > abi:
				abi = j
			j = 0
		else:
			j += 1
	j += 1
	if j > abi:
		abi = j
	return abi
print(jump(input()))


data = input() + 'A'
vowels = ['A', 'E', 'I', 'O', 'U', 'Y']
first = 0
second = 0
my_max = 0
for (index, letter) in enumerate(data):
	if letter in vowels:
		first = second
		second = index + 1
		my_max = max(my_max, second - first)
print(my_max)


glas = ['A', 'E', 'I', 'O', 'U', 'Y']
input_without_glas = ''.join([' ' if symbol in glas else symbol for symbol in input()]).split()
length = [len(elem) for elem in input_without_glas]
if length:
	print(max(length) + 1)
else:
	print(1)


s = 'A' + input('') + 'A'
last = 0
maxJump = 0
for (i, x) in enumerate(s):
	if x in ['A', 'E', 'I', 'O', 'U', 'Y']:
		maxJump = max(maxJump, i - last)
		last = i
print(maxJump)


inl = [x for x in input()]
maxd = 1
vowels = set(['A', 'E', 'I', 'O', 'U', 'Y'])
curr = 0
for c in inl:
	curr += 1
	if c in vowels:
		if curr > maxd:
			maxd = curr
		curr = 0
curr += 1
if curr > maxd:
	maxd = curr
curr = 0
print(maxd)


n = input() + 'A'
step = 1
answ = 1
for i in n:
	if i == 'A' or i == 'E' or i == 'I' or (i == 'O') or (i == 'U') or (i == 'Y'):
		if answ < step:
			answ = step
		step = 1
	else:
		step += 1
print(answ)


s = input()
L = len(s)
D = 0
cnt = 0
for i in range(0, L):
	if s[i] == 'A' or s[i] == 'E' or s[i] == 'I' or (s[i] == 'O') or (s[i] == 'U') or (s[i] == 'Y'):
		cnt = max(cnt, D)
		D = 0
	else:
		D += 1
cnt = max(cnt, D)
print(cnt + 1)


def Main():
	v = ['A', 'E', 'I', 'O', 'U', 'Y']
	s = input()
	A = []
	cnt = 0
	for i in range(len(s)):
		if s[i] == 'A' or s[i] == 'E' or s[i] == 'I' or (s[i] == 'O') or (s[i] == 'U') or (s[i] == 'Y'):
			A.append(cnt)
			cnt = 0
		else:
			cnt += 1
	A.append(cnt)
	A.sort()
	print(A[len(A) - 1] + 1)
Main()


n = input()
l = 1
j = 1
for i in n:
	if i == 'A' or i == 'E' or i == 'I' or (i == 'O') or (i == 'U') or (i == 'Y'):
		if j > l:
			l = j
		j = 0
	j = j + 1
if j > l:
	l = j
print(l)


s = input()
c = 0
d = 0
for i in range(len(s)):
	if not (s[i] == 'A' or s[i] == 'E' or s[i] == 'I' or (s[i] == 'O') or (s[i] == 'U') or (s[i] == 'Y')):
		c += 1
		if c > d:
			d = c
	else:
		c = 0
print(d + 1)


line = input()
maxjump = 1
currentjump = 1
for i in range(0, len(line)):
	if line[i] == 'A' or line[i] == 'E' or line[i] == 'I' or (line[i] == 'O') or (line[i] == 'U') or (line[i] == 'Y'):
		if currentjump > maxjump:
			maxjump = currentjump
		currentjump = 1
	else:
		currentjump += 1
if currentjump > maxjump:
	maxjump = currentjump
print(maxjump)


string = list(input())
maxJump = 0
count = 1
vowels = ['A', 'E', 'I', 'O', 'U', 'Y']
n = len(string)
for i in range(0, n):
	if string[i] not in vowels:
		count += 1
	else:
		if maxJump < count:
			maxJump = count
		count = 1
	if i == n - 1:
		if maxJump < count:
			maxJump = count
print(maxJump)


s = input()
counter = 0
tmp = 0
z = 'AEIOUY'
for i in s:
	if i in z:
		tmp = max(tmp, counter)
		counter = 0
	else:
		counter += 1
tmp = max(tmp, counter)
print(tmp + 1)


vowels = 'AEIOUY'
s = input()
Max = -1
tool = 1
for i in s:
	if i in vowels:
		if tool > Max:
			Max = tool
		tool = 1
	else:
		tool += 1
print(max(tool, Max))


from collections import deque as de
import math
from collections import Counter as cnt
from functools import reduce
from typing import MutableMapping
from itertools import groupby as gb
from fractions import Fraction as fr

def factors(n):
	return set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0)))

class My_stack:

	def __init__(self):
		self.data = []

	def my_push(self, x):
		return self.data.append(x)

	def my_pop(self):
		return self.data.pop()

	def my_peak(self):
		return self.data[-1]

	def my_contains(self, x):
		return self.data.count(x)

	def my_show_all(self):
		return self.data

	def isEmpty(self):
		return len(self.data) == 0
arrStack = My_stack()

def decimalToBinary(n):
	return bin(n).replace('0b', '')

def isPrime(n):
	if n <= 1:
		return False
	if n <= 3:
		return True
	if n % 2 == 0 or n % 3 == 0:
		return False
	i = 5
	while i * i <= n:
		if n % i == 0 or n % (i + 2) == 0:
			return False
		i = i + 6
	return True

def get_prime_factors(number):
	prime_factors = []
	while number % 2 == 0:
		prime_factors.append(2)
		number = number / 2
	for i in range(3, int(math.sqrt(number)) + 1, 2):
		while number % i == 0:
			prime_factors.append(int(i))
			number = number / i
	if number > 2:
		prime_factors.append(int(number))
	return prime_factors

def get_frequency(list):
	dic = {}
	for ele in list:
		if ele in dic:
			dic[ele] += 1
		else:
			dic[ele] = 1
	return dic

def Log2(x):
	return math.log10(x) / math.log10(2)

def isPowerOfTwo(n):
	return math.ceil(Log2(n)) == math.floor(Log2(n))

def ceildiv(x, y):
	return (x + y - 1) // y

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

def li():
	return list(map(int, input().split()))
s = input()
curr = 0
mn = 0
for i in range(len(s)):
	if s[i] == 'A' or s[i] == 'I' or s[i] == 'O' or (s[i] == 'U') or (s[i] == 'E') or (s[i] == 'Y'):
		diff = i + 1 - curr
		curr = i + 1
		if diff > mn:
			mn = diff
diff = len(s) - curr + 1
if diff > mn:
	mn = diff
print(mn)


__author__ = 'artyom'
vowels = 'AEIOUY'

def main():
	s = read(0) + 'A'
	p = -1
	mx = 1
	for i in range(len(s)):
		if s[i] in vowels:
			cr = i - p
			if cr > mx:
				mx = cr
			p = i
	return mx

def read(mode=1, size=None):
	if mode == 0:
		return input().strip()
	if mode == 1:
		return int(input().strip())
	if mode == 2:
		return input().strip().split()
	if mode == 3:
		return list(map(int, input().strip().split()))
	a = []
	for _ in range(size):
		a.append(read(3))
	return a

def write(s='\n'):
	if s is None:
		s = ''
	if isinstance(s, tuple) or isinstance(s, list):
		s = ' '.join(map(str, s))
	s = str(s)
	print(s, end='\n')
write(main())


s = input()
s += 'A'
ans = 0
m = 0
for f in range(len(s)):
	if s[f] == 'A' or s[f] == 'E' or s[f] == 'I' or (s[f] == 'O') or (s[f] == 'U') or (s[f] == 'Y'):
		m += 1
		if m > ans:
			ans = m
		m = 0
	else:
		m += 1
print(ans)


s = 'A' + input() + 'A'
ans = 0
front = 0
vowel = ['A', 'E', 'I', 'O', 'U', 'Y']
for i in range(1, len(s)):
	if s[i] in vowel:
		ans = max(ans, i - front)
		front = i
print(ans)


vowels = ['A', 'E', 'I', 'O', 'U', 'Y']
ans = 0
count = 1
for i in list(input()):
	if i in vowels:
		ans = max(ans, count)
		count = 1
	else:
		count += 1
print(max(ans, count))


vowels = 'AEIOUY'
s = list(input())
counter = 1
ans = 1
for i in range(len(s)):
	if s[i] not in vowels:
		counter += 1
		continue
	else:
		if counter > ans:
			ans = counter
		counter = 1
if counter > ans:
	ans = counter
print(ans)


s = input()
(h, p) = (-1, -1)
for i in range(len(s)):
	if s[i] == 'A' or s[i] == 'E' or s[i] == 'I' or (s[i] == 'O') or (s[i] == 'U') or (s[i] == 'Y'):
		if i - p > h:
			h = i - p
		p = i
if len(s) - p > h:
	h = len(s) - p
print(h)


s = str(input())
d = 0
dis = 0
l = []
for i in range(0, len(s)):
	if s[i] in 'AEIUOY':
		dis = i + 1 - d
		d = i + 1
		l.append(dis)
l.append(len(s) + 1 - d)
if len(l) == 0:
	print(len(s) + 1)
else:
	print(max(l))


string = input()
vowel = 1
maxvowel = 0
is_vowel = False
for x in range(len(string)):
	if string[x] == 'A' or string[x] == 'E' or string[x] == 'I' or (string[x] == 'O') or (string[x] == 'U') or (string[x] == 'Y'):
		is_vowel = True
		vowel = 1
	else:
		is_vowel = False
		vowel += 1
	if vowel > maxvowel:
		maxvowel = vowel
print(maxvowel)


s = ['A', 'E', 'I', 'O', 'U', 'Y']
i = input()
ans = 0
count = 0
for x in i:
	if x not in s:
		count = count + 1
		ans = max(count, ans)
	else:
		count = 0
print(ans + 1)


a = input()
a = 'A' + a + 'A'
b = ['A', 'E', 'I', 'O', 'U', 'Y']
caunt = 0
max = 1
for i in range(len(a)):
	if a[i] not in b:
		caunt += 1
	else:
		if caunt + 1 > max:
			max = caunt + 1
		caunt = 0
print(max)


s = list(input()) + ['A']
vow = ['A', 'E', 'I', 'O', 'U', 'Y']
dec = []
x = 1
for i in range(len(s)):
	if s[i] in vow:
		dec.append(x)
		x = 1
	else:
		x += 1
print(max(dec))


x = 'AEIOUY'
pos = -1
a = input()
ans = 0
n = len(a)
for i in range(n):
	if a[i] in x:
		ans = max(ans, i - pos)
		pos = i
print(max(ans, n - pos))


s = 'A' + input() + 'A'
(a, b, m) = (0, 0, 0)
for (i, c) in enumerate(s):
	if c in 'AEIOUY':
		(a, b) = (b, i)
	m = max(b - a, m)
print(m)


s = input()
res = 1
curr = 1
vowels = ['A', 'E', 'I', 'O', 'U', 'Y']
for a in s:
	if a in vowels:
		curr = 1
	else:
		curr += 1
		res = max(res, curr)
print(res)


str = input()
len = len(str)
i = 0
ans = 0
count = 0
while i <= len:
	if i == len:
		ans = count + 1 if count + 1 > ans else ans
		count = 0
	elif str[i] == 'A' or str[i] == 'E' or str[i] == 'I' or (str[i] == 'O') or (str[i] == 'U') or (str[i] == 'Y'):
		ans = count + 1 if count + 1 > ans else ans
		count = 0
	else:
		count += 1
	i += 1
print(ans)


n = input()
res = 1
cont = 1
for i in n:
	if i != 'A' and i != 'E' and (i != 'I') and (i != 'O') and (i != 'U') and (i != 'Y'):
		cont += 1
		if cont > res:
			res = cont
	else:
		cont = 1
print(res)


import math, sys, bisect, heapq
from collections import defaultdict, Counter, deque
from itertools import groupby, accumulate
input = iter(sys.stdin.buffer.read().decode().splitlines()).__next__
ilele = lambda : map(int, input().split())
alele = lambda : list(map(int, input().split()))

def list2d(a, b, c):
	return [[c] * b for i in range(a)]

def list3d(a, b, c, d):
	return [[[d] * c for j in range(b)] for i in range(a)]

def Y(c):
	print(['NO', 'YES'][c])

def y(c):
	print(['no', 'yes'][c])

def Yy(c):
	print(['No', 'Yes'][c])
S = input()
S = 'A' + S + 'A'
A = ['A', 'E', 'I', 'O', 'U', 'Y']
T = [*S]
Ans = 0
temp = 0
for i in range(1, len(T)):
	if T[i] in A:
		dis = i - temp
		temp = i
		Ans = max(Ans, dis)
print(Ans)


from functools import reduce
arr = list(input())
vowels = list([i for i in range(len(arr)) if arr[i] == 'A' or arr[i] == 'E' or arr[i] == 'I' or (arr[i] == 'O') or (arr[i] == 'U') or (arr[i] == 'Y')])
if len(vowels) != 0:
	dist = []
	dist.append(vowels[0] + 1)
	for i in range(len(vowels) - 1):
		dist.append(vowels[i + 1] - vowels[i])
	dist.append(len(arr) - vowels[len(vowels) - 1])
	print(reduce(max, dist))
else:
	print(len(arr) + 1)


s = input()
s = 'A' + s + 'A'
counter = 0
k = 0
for i in s:
	if i == 'A' or i == 'E' or i == 'I' or (i == 'O') or (i == 'U') or (i == 'Y'):
		counter = max(k, counter)
		k = 1
	else:
		k += 1
print(counter)


s = input()
VOWELS = ('A', 'I', 'E', 'O', 'U', 'Y')
min = 1
m = 1
lastcharacter = -1
l = len(s)
for i in range(l):
	if s[i] in VOWELS:
		if i - lastcharacter > min:
			min = i - lastcharacter
		lastcharacter = i
if l - lastcharacter > min:
	min = l - lastcharacter
print(min)


is_debug = False
c = ['A', 'E', 'I', 'O', 'U', 'Y']
s = input()
l = len(s)
j = 0
t = -1
for i in range(1, l + 1):
	if s[i - 1] in c:
		print(f's[i]={s[i - 1]}, i-j={i - j}', end='|') if is_debug else ''
		t = max(t, i - j)
		j = i
		print(f't={t}') if is_debug else ''
t = max(t, l + 1 - j)
print(f'{t}')


s = input()
vowels = 'AEIOUY'
flag = False
cur = 1
m = 0
for c in s:
	if c not in vowels:
		cur += 1
	else:
		flag = True
		m = max(m, cur)
		cur = 1
if flag == False:
	m = len(s) + 1
print(max(m, cur))


a = input()
maxi = 0
ans = 0
for i in range(0, len(a)):
	if a[i] != 'A' and a[i] != 'E' and (a[i] != 'I') and (a[i] != 'O') and (a[i] != 'U') and (a[i] != 'Y'):
		ans = ans + 1
		if maxi < ans:
			maxi = ans
	else:
		ans = 0
print(maxi + 1)


s = '0' + input() + '1'
l = 'AEIOUY1'
(i, k, mx, p, ls) = (0, 0, 0, 0, 0)
while i < len(s):
	if s[i] in l:
		k = i - p
		p = i
		if mx < k:
			mx = k
			ls = 1
	i += 1
if ls == 1:
	print(mx)
else:
	print(len(s) - 1)


s = input()
n = 0
maxi = 1
m = 'AEOUIYaeouiy'
for i in range(len(s) + 1):
	if i < len(s) and (not s[i] in m):
		n += 1
	elif n > 0:
		if n + 1 > maxi:
			maxi = n + 1
		n = 0
print(maxi)


n = input()
s = 0
lst = []
z = 0
for i in n:
	if i != 'A' and i != 'E' and (i != 'I') and (i != 'O') and (i != 'U') and (i != 'Y'):
		s = s + 1
		z = 0
	else:
		z = z + 1
		s = s + 1
		lst.append(s)
		s = 0
if z == 0:
	lst.append(s + 1)
print(max(lst))


letters = input().strip()
maxi = 0
jump = 0
last = letters[len(letters) - 1]
for i in letters:
	jump += 1
	if i in {'A', 'E', 'I', 'O', 'U', 'Y'}:
		if jump > maxi:
			maxi = jump
		jump = 0
jump += 1
if jump > maxi:
	maxi = jump
print(maxi)


c1 = 0
c2 = 0
pr = 0
gl = ['A', 'E', 'O', 'U', 'I', 'Y']
s = input()
for i in range(len(s)):
	if s[i] in gl:
		c2 = i + 1
		if c2 - c1 > pr:
			pr = c2 - c1
	c1 = c2
if pr == 0:
	pr = len(s) + 1
if len(s) + 1 - c1 > pr:
	pr = len(s) + 1 - c2
print(pr)


x = 'AEIOUY'
y = input()
a = 0
b = 0
for i in y:
	a += 1
	if a > b:
		b = a
	if i in x:
		a = 0
if a == b:
	b += 1
print(b)


string = input()
vowels = ['A', 'E', 'I', 'O', 'U', 'Y']
jumps = []
jump = 1
for x in string:
	if x in vowels:
		jumps.append(jump)
		jump = 1
	else:
		jump += 1
jumps.append(jump)
print(max(jumps))


s = input()
s = 'A' + s + 'A'
n = [i for (i, e) in enumerate(s) if e in ['A', 'E', 'O', 'U', 'I', 'Y']]
for i in range(len(n) - 1):
	n[i] = n[i + 1] - n[i]
print(max(n[:-1]))


def isVowel(x):
	return x == 'A' or x == 'E' or x == 'I' or (x == 'O') or (x == 'U') or (x == 'Y')
xs = input()
maxJump = 0
jumpFrom = -1
for i in range(0, len(xs)):
	x = xs[i]
	if isVowel(x):
		maxJump = max(maxJump, i - jumpFrom)
		jumpFrom = i
if jumpFrom < len(xs) - 1:
	maxJump = max(maxJump, len(xs) - jumpFrom)
print(maxJump)


a = input()
(count, ans) = (1, 1)
for b in a:
	if b not in 'AEIOUY':
		count += 1
	else:
		count = 1
	ans = count if count > ans else ans
print(ans)


jump = input()
jump = jump + 'C'
vowels = ['A', 'E', 'I', 'O', 'U', 'Y']
indexes = []
for item in jump:
	if item in vowels:
		indexes.append(1)
	else:
		indexes.append(0)
jumps = []
jump_num = 0
for item in indexes:
	jump_num += 1
	if item == 1:
		jumps.append(jump_num)
		jump_num = 0
jumps.append(jump_num)
print(max(jumps))


s = list(input())
k = ['A']
s.append('A')
for i in range(len(s)):
	k.append(s[i])
max = 0
p_pos = 0
count = 0
v = ['A', 'E', 'I', 'O', 'U', 'Y']
for i in range(len(k)):
	if k[i] in v:
		c_pos = i
		j_l = c_pos - p_pos
		p_pos = i
		count += 1
		if j_l > max:
			max = j_l
if count > 0:
	if count == 1:
		print(max + 1)
	else:
		print(max)
else:
	print(len(s) + 1)


import math
str1 = input()
m = 1
max = 1
b = ['A', 'E', 'I', 'O', 'U', 'Y']
for z in str1:
	if z in b:
		m = 1
	else:
		m += 1
	if m > max:
		max = m
print(max)


s = input()
st = 'AEIOUY'
cnt = 0
m = 0
for i in range(len(s)):
	if s[i] not in st:
		cnt += 1
		if i == len(s) - 1:
			m = max(m, cnt)
	else:
		m = max(m, cnt)
		cnt = 0
print(max(1, m + 1))


def main():
	s = input()
	s = 'A' + s + 'A'
	last = 0
	gap = 0
	for i in range(1, len(s)):
		if s[i] in 'AEIOUY':
			gap = max(i - last, gap)
			last = i
	print(gap)
main()


(a, b) = (1, 1)
for i in input() + 'A':
	if i in 'AEIOUY':
		a = max(a, b)
		b = 1
	else:
		b += 1
print(a)


s = 'A' + input() + 'A'
(last, ans) = (0, 0)
for (i, ch) in enumerate(s):
	if ch in ['A', 'E', 'I', 'O', 'U', 'Y']:
		ans = max(ans, i - last)
		last = i
print(ans)


a = 'A' + input() + 'A'
b = 0
lst = ['A', 'E', 'I', 'O', 'U', 'Y']
lst1 = [x + 1 for (x, y) in enumerate(a) if y in lst]
for x in range(1, len(lst1)):
	z = lst1[x] - lst1[x - 1]
	if z > b:
		b = z
print(b)


a = '0'
a += input()
a += '0'
pos = 0
max_1 = 0
for i in range(1, len(a) - 1):
	if a[i] == 'A' or a[i] == 'E' or a[i] == 'I' or (a[i] == 'O') or (a[i] == 'U') or (a[i] == 'Y'):
		if i - pos > max_1:
			max_1 = i - pos
		pos = i
if pos != len(a) and len(a) - pos - 1 > max_1:
	max_1 = len(a) - 1 - pos
print(max_1)


VOWELS = ['A', 'E', 'I', 'O', 'U', 'Y']
leaf = 'A' + input() + 'A'
indeces_of_vowels = []
for (index, letter) in enumerate(leaf):
	if letter in VOWELS:
		indeces_of_vowels.append(index)
m = 1
for i in range(1, len(indeces_of_vowels)):
	m = max(m, indeces_of_vowels[i] - indeces_of_vowels[i - 1])
print(m)


def f(c, l):
	return {i for i in range(len(l)) if c == l[i]}
s = input()
l = sorted(f('A', s) | f('E', s) | f('I', s) | f('O', s) | f('U', s) | f('Y', s) | {-1, len(s)})
print(max((l[i + 1] - l[i] for i in range(len(l) - 1))))


st = input()
st += '0'
ind = []
distance = 0
vowels = ['A', 'E', 'I', 'O', 'U', 'Y']
for i in st:
	distance += 1
	if i in vowels:
		ind.append(distance)
		distance = 0
ind.append(distance)
print(max(ind))


import re
s = input()
s = re.sub('[AEIOUY]', ' ', s)
ll = s.split()
m = 0
for l in ll:
	m = max(m, len(l))
print(m + 1)


s = input().strip()
glas = 'AEIOUY'
ll = [0]
j = 0
for i in range(1, len(s) + 1):
	if s[i - 1] in glas:
		ll.append(i - j)
		j = i
ll.append(len(s) - j + 1)
print(max(ll))


s = 'A' + input().strip() + 'A'
prev = x = -1
for i in range(len(s)):
	if s[i] in ['A', 'E', 'I', 'O', 'U', 'Y']:
		if prev == -1:
			prev = i
		else:
			x = max(x, i - prev)
			prev = i
print(x)


s = list(map(str, input()))
d = ['A', 'E', 'I', 'O', 'U', 'Y']
max = 0
i = 1
for x in s:
	if x not in d:
		i += 1
	else:
		i = 1
	if i > max:
		max = i
print(max)


l = list(input())
sadonok = ['A', 'E', 'I', 'O', 'U', 'Y']
(x, ans, z) = ([], [], [])
if len(l) == 1 and l[0] in sadonok:
	print(1)
	exit()
for i in range(len(sadonok)):
	z.append(l.count(sadonok[i]))
if sum(z) == 0:
	print(len(l) + 1)
else:
	for i in range(len(l)):
		for j in range(len(sadonok)):
			if l[i] == sadonok[j]:
				x.append(l.index(l[i]))
				l[i] = 'W'
	if len(x) == 1:
		print(max(x[0] + 1, abs(x[0] - len(l))))
	else:
		for i in range(len(x) - 1):
			ans.append(abs(x[i] - x[i + 1]))
		ans.append(abs(x[-1] - len(l)))
		ans.append(x[0] + 1)
		print(max(ans))


s = input().rstrip()
x = list(s)
S = 0
w = []
l = ['A', 'E', 'I', 'O', 'U', 'Y']
for i in range(0, len(x)):
	if x[i] in l:
		w.append(i + 1 - S)
		S = i + 1
w.append(len(x) + 1 - S)
print(max(w))


(a, c, l, d) = (input(), 0, ['A', 'E', 'I', 'O', 'U', 'Y'], 0)
for x in range(len(a)):
	if a[x] in l:
		if x + 1 - c > d:
			d = x + 1 - c
		c = x + 1
print(max(d, len(a) - c + 1))


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time, copy, functools
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
eps = 1.0 / 10 ** 10
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 LI_():
	return [int(x) - 1 for x in sys.stdin.readline().split()]

def LF():
	return [float(x) for x in sys.stdin.readline().split()]

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

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

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

def S():
	return input()

def pf(s):
	return print(s, flush=True)

def main():
	s = S()
	t = 'AEIOUY'
	k = 1
	r = 1
	for c in s:
		if c in t:
			if r < k:
				r = k
			k = 1
		else:
			k += 1
	if r < k:
		r = k
	return r
print(main())


s = input()
n = len(s)
t = -1
m = -1
for i in range(n):
	if s[i] in 'AEIOUY':
		m = max(m, i - t)
		t = i
m = max(m, n - t)
print(m)


def isVowel(c):
	if c == 'A' or c == 'E' or c == 'I' or (c == 'O') or (c == 'U') or (c == 'Y'):
		return True
	else:
		return False
string = input()
if len(string) == 1:
	if isVowel(string[0]):
		print(1)
	else:
		print(2)
else:
	x = 1
	jumps = 1
	for i in string:
		if isVowel(i):
			if x >= jumps:
				jumps = x
			x = 1
		else:
			x += 1
	if x >= jumps:
		jumps = x
	print(jumps)


kata = input()
max = 0
j = 0
for i in kata:
	if i in 'AEIOUY':
		j = 0
	else:
		j += 1
		if j > max:
			max = j
print(max + 1)


s = input()
l = list()
ip = -1
for i in range(len(s)):
	if s[i] == 'A' or s[i] == 'E' or s[i] == 'I' or (s[i] == 'O') or (s[i] == 'U') or (s[i] == 'Y'):
		val = i
		l.append(val - ip)
		ip = val
if l:
	l.append(len(s) - ip)
	print(max(l))
else:
	print(len(s) - -1)


inp = input()
cur = -1
ans = 0
for i in range(len(inp)):
	if inp[i] == 'A' or inp[i] == 'E' or inp[i] == 'I' or (inp[i] == 'O') or (inp[i] == 'U') or (inp[i] == 'Y'):
		ans = max(i - cur, ans)
		cur = i
ans = max(len(inp) - cur, ans)
print(ans)


a = input()
a = a + 'A'
l = ['A', 'E', 'I', 'O', 'U', 'Y']
maximum = 0
j = 0
z = 0
e = z
for i in range(len(a)):
	j = j + 1
	if a[i] in l:
		if j > maximum:
			maximum = j
		j = 0
if maximum == 0:
	print(len(x) + 1)
else:
	print(maximum)


s = input()
vow = ['A', 'E', 'I', 'O', 'U', 'Y']
p = []
stack = []
l = 0
for i in range(len(s)):
	if s[i] in vow:
		l += 1
		p.append(l)
		l = 0
	else:
		l += 1
l += 1
p.append(l)
print(max(p))


s = input()
a = ['A', 'E', 'O', 'I', 'U', 'Y']
c = 0
x = 0
for i in range(len(s)):
	c += 1
	if s[i] in a:
		x = max(c, x)
		c = 0
c += 1
print(max(c, x))


a = input()
first = 0
second = -1
maximum = 0
for i in range(len(a)):
	if a[i] in 'AUIOYE':
		first = second
		second = i
		if maximum <= second - first:
			maximum = second - first
	elif i == len(a) - 1:
		first = second
		second = i + 1
		if maximum <= second - first:
			maximum = second - first
print(maximum)


s = input() + 'A'
m = 1
_m = 1
for c in s:
	if c in 'AEIOUY':
		m = max(m, _m)
		_m = 1
	else:
		_m += 1
print(m)


vow = ['A', 'O', 'I', 'U', 'E', 'Y']
ans = 0
bfr = -1
string = input()
panjang = len(string)
for i in range(panjang):
	if string[i] in vow:
		ans = max(ans, i - bfr)
		bfr = i
ans = max(ans, panjang - bfr)
print(ans)


def is_vowel(letter):
	return letter in 'AEIOUY'

def main(arg):
	biggest = 1
	current = 1
	for letter in arg:
		if is_vowel(letter):
			biggest = current if current > biggest else biggest
			current = 1
		else:
			current += 1
	biggest = current if current > biggest else biggest
	return biggest
while True:
	try:
		print(main(input()))
	except:
		break


s = input()
v = ['A', 'E', 'I', 'O', 'U', 'Y']
c = 0
b = []
for i in range(len(s)):
	if s[i] in v:
		b.append(i)
if len(s) == 1:
	if s in v:
		print(1)
	else:
		print(2)
elif len(b) == 0:
	print(len(s) + 1)
elif len(b) == 1:
	print(max(b[0] + 1, len(s) - b[0]))
else:
	l = []
	for i in range(1, len(b)):
		l.append(b[i] - b[i - 1])
	print(max(max(l), b[0] + 1, len(s) - b[-1]))


put = input()
jump = 0
ans = 0
for letters in put.upper():
	if letters == 'A' or letters == 'E' or letters == 'I' or (letters == 'O') or (letters == 'U') or (letters == 'Y'):
		jump += 1
		if jump > ans:
			ans = jump
		jump = 0
	else:
		jump += 1
jump += 1
if jump > ans:
	ans = jump
print(ans)


from sys import stdin as fin
line = fin.readline().strip()
son = ('A', 'E', 'I', 'O', 'U', 'Y')
prev = -1
maxv = 1
n = len(line)
for i in range(n):
	if line[i] in son:
		maxv = max(maxv, i - prev)
		prev = i
print(max(maxv, n - prev) if line[-1] not in son else maxv)


string = input()
(m, c) = (1, 1)
vowels = ['A', 'E', 'I', 'O', 'U', 'Y']
for i in string:
	if i in vowels:
		c = 1
	else:
		c += 1
	if c > m:
		m = c
print(m)


s = input()
count = 0
list3 = []
list1 = []
list2 = ['A', 'E', 'I', 'O', 'U', 'Y']
for j in s:
	list1.append(j)
for j in range(len(list1)):
	if list1[j] not in list2:
		count += 1
		list3.append(count)
	elif list1[j] in list2:
		count = 0
		list3.append(count)
print(max(list3) + 1)


s = 'A' + input() + 'A'
g = 'AEUYIO'
ans = 0
last = 0
for i in range(len(s)):
	if s[i] in g:
		ans = max(ans, i - last)
		last = i
if ans != 0:
	print(ans)
else:
	print(len(s))


s = input()
a = [0]
for i in range(len(s)):
	if s[i] in 'AEIOUY':
		a.append(i + 1)
a.append(len(s) + 1)
ans = 0
for i in range(1, len(a)):
	ans = max(ans, a[i] - a[i - 1])
print(ans)


s = 'Y' + input() + 'Y'
index = []
vow = set(['A', 'E', 'I', 'O', 'U', 'Y'])
for i in range(len(s)):
	if s[i] in vow:
		index.append(i)
ans = []
for i in range(len(index) - 1):
	ans.append(index[i + 1] - index[i])
print(max(set(ans)))


import sys
fin = sys.stdin
fout = sys.stdout
m = -1
gl = {'A', 'E', 'I', 'O', 'U', 'Y'}
s = fin.readline().strip()
cur = -1
for i in range(len(s)):
	if s[i] in gl:
		m = max(m, i - cur)
		cur = i
m = max(m, len(s) - cur)
fout.write(str(m))


import sys
LETTERS = {'A', 'E', 'I', 'O', 'U', 'Y'}
line = sys.stdin.readline().strip()
max_count = 0
current_count = 0
for ch in line:
	if ch in LETTERS:
		max_count = max(max_count, current_count)
		current_count = 0
	else:
		current_count += 1
max_count = max(max_count, current_count)
print(max_count + 1)


s = input()
a = []
for i in range(len(s)):
	if s[i] == 'A' or s[i] == 'E' or s[i] == 'U' or (s[i] == 'I') or (s[i] == 'O') or (s[i] == 'Y'):
		a.append(1)
	else:
		a.append(0)
a.append(1)
num = 0
maximum = 0
for i in range(len(a)):
	num += 1
	if a[i] == 1:
		maximum = max(maximum, num)
		num = 0
print(maximum)


print(1 + max((len(z) for z in input().translate(str.maketrans('AEIOUY', '      ')).split(' '))))


get_int = lambda : map(int, input().split())
s = input()
x = 1
ans = 1
for i in s:
	if i in 'AEIOUY':
		if ans < x:
			ans = x
		x = 1
	else:
		x += 1
print(max(x, ans))


string = input()
jump = 1
current = 1
for char in string:
	if not char in 'AIUEOY':
		current += 1
		if current > jump:
			jump = current
	else:
		current = 1
print(jump)


n = input()
l = len(n)
a = 'AEIOUY'
j = -1
ans = 0
for i in range(l):
	if n[i] in a:
		ans = max(ans, i - j)
		j = i
ans = max(l - j, ans)
if j == -1:
	print(l + 1)
else:
	print(ans)


def main():
	i = res = -1
	for (j, c) in enumerate(input() + 'A'):
		if c in 'AEIOUY':
			if res < j - i:
				res = j - i
			i = j
	print(res)
main()


vowels = {'A', 'E', 'I', 'O', 'U', 'Y'}
n = input()
n = 'A' + n + 'A'
ct = 0
prev = 0
ans = 0
for i in range(len(n)):
	if n[i] in vowels:
		ct = i - prev
		if ct > ans:
			ans = ct
		prev = i
print(ans)


s = input()
s = s.replace('A', ' ').replace('E', ' ').replace('I', ' ').replace('O', ' ').replace('U', ' ').replace('Y', ' ')
lengths = map(len, s.split(' '))
print(max(lengths) + 1)


s = 'A' + input() + 'A'
maxi = -8
prev = 0
for i in range(1, len(s)):
	if s[i] in ['A', 'E', 'I', 'O', 'U', 'Y']:
		maxi = max(maxi, i - prev)
		prev = i
print(maxi)


s = input()
s += 'A'
ss = {'A', 'E', 'I', 'O', 'U', 'Y'}
cnt = 1
ans = 0
for i in range(len(s)):
	ans = max(ans, cnt)
	if s[i] in ss:
		cnt = 1
	else:
		cnt += 1
print(ans)


vowels = 'AEIOUY'
inp = input()
max_jump = 1
current_len = 1
for c in inp:
	if c in vowels:
		max_jump = max(max_jump, current_len)
		current_len = 1
	else:
		current_len += 1
max_jump = max(max_jump, current_len)
print(max_jump)


s = input()
s = s.replace('A', ' ')
s = s.replace('E', ' ')
s = s.replace('O', ' ')
s = s.replace('I', ' ')
s = s.replace('U', ' ')
s = s.replace('Y', ' ')
s = s.split(' ')
print(max([len(x) for x in s]) + 1)


import re
s = input()
s = re.split('[AEIOUY]', s)
res = list()
for i in range(len(s)):
	res.append(len(s[i]))
res.sort(reverse=True)
print(res[0] + 1)


vowels = ['A', 'E', 'I', 'O', 'U', 'Y']
jump = 0
symbols = input()
location = [-1]
for (index, symbol) in enumerate(symbols):
	if symbol in vowels:
		location.append(index)
location.append(len(symbols))
for (index, start) in enumerate(location):
	try:
		if location[index + 1] - start > jump:
			jump = location[index + 1] - start
	except:
		pass
print(jump)


def isvowel(x):
	return x in 'AEIOUY'
s = 'A' + input() + 'A'
a = []
for (i, c) in enumerate(s):
	if isvowel(c):
		a.append(i)
ans = 0
for i in range(len(a) - 1):
	ans = max(ans, a[i + 1] - a[i])
print(ans)


from operator import *
s = [i for (i, x) in enumerate('A' + input() + 'A') if x in 'AEIOUY']
print(max(map(sub, s[1:], s)))


a = ['A']
a.extend(list(input()))
a.append('A')
b = [int(0)] * len(a)
for i in range(1, len(a)):
	if a[i] != 'A' and a[i] != 'E' and (a[i] != 'I') and (a[i] != 'O') and (a[i] != 'U') and (a[i] != 'Y'):
		b[i] = int(b[i - 1] + 1)
print(int(max(b) + 1))


l1 = input()
vowels = 'AEIOUY'
ans = 1
temp = 1
for x in range(len(l1)):
	if l1[x] in vowels:
		temp = 1
	else:
		temp += 1
	ans = max(temp, ans)
print(ans)


way = input()
vowels = ['A', 'E', 'I', 'O', 'U', 'Y']
max_jump = 1
jump = 0
for i in range(len(way)):
	jump += 1
	if way[i] in vowels or i == len(way) - 1:
		if i == len(way) - 1 and (not way[i] in vowels):
			jump += 1
		if jump > max_jump:
			max_jump = jump
		jump = 0
print(max_jump)


line = input().strip() + 'A'
vowels = 'AEIOUY'
ans = -1
last = -1
for (i, one) in enumerate(line):
	if one in vowels:
		ans = max(ans, i - last)
		last = i
if ans == -1:
	print(len(line) + 1)
else:
	print(ans)


vowels = set(['A', 'E', 'I', 'O', 'U', 'Y'])
z = [i for (i, ch) in enumerate('A' + input() + 'A') if ch in vowels]
print(max([z[i + 1] - z[i] for i in range(len(z) - 1)]))


string = input()
LIST = ['A', 'E', 'I', 'O', 'U', 'Y']
temp = []
total_list = []
for (n, i) in enumerate(string):
	if i not in LIST:
		temp.append(i)
	else:
		total_list.append(temp)
		temp = []
if temp:
	total_list.append(temp)
	temp = []
print(len(max(total_list, key=len)) + 1)


s = input()
vowels = 'AEIOUY'
pre = -1
ans = 0
for (i, c) in enumerate(s):
	if c in vowels:
		ans = max(ans, i - pre)
		pre = i
ans = max(ans, len(s) - pre)
print(ans)