Problem: 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

Solution (in JAVA):

Solution:
import java.util.Scanner;
import java.io.*;
import java.util.*;
import java.math.*;
import static java.lang.Math.*;
 
public class Main
{	
	static class InputReader
	{
		private InputStream stream;
		private byte[] buf = new byte[1024];
		private int curChar;
		private int numChars;
		private SpaceCharFilter filter;
		
		public InputReader(InputStream stream)
		{
			this.stream = stream;
		}
		
		public int read()
		{
			if (numChars==-1) 
				throw new InputMismatchException();
			
			if (curChar >= numChars)
			{
				curChar = 0;
				try 
				{
					numChars = stream.read(buf);
				}
				catch (IOException e)
				{
					throw new InputMismatchException();
				}
				
				if(numChars <= 0)				
					return -1;
			}
			return buf[curChar++];
		}
	 
		public String nextLine()
		{
			BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
			String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
		}
		public int nextInt()
		{
			int c = read();
			
			while(isSpaceChar(c)) 
				c = read();
			
			int sgn = 1;
			
			if (c == '-') 
			{
				sgn = -1;
				c = read();
			}
			
			int res = 0;
			do 
			{
				if(c<'0'||c>'9') 
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			}
			while (!isSpaceChar(c)); 
			
			return res * sgn;
		}
		
		public long nextLong() 
		{
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-') 
			{
				sgn = -1;
				c = read();
			}
			long res = 0;
			
			do 
			{
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			}
			while (!isSpaceChar(c));
				return res * sgn;
		}
		
		public double nextDouble() 
		{
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-') 
			{
				sgn = -1;
				c = read();
			}
			double res = 0;
			while (!isSpaceChar(c) && c != '.') 
			{
				if (c == 'e' || c == 'E')
					return res * Math.pow(10, nextInt());
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			}
			if (c == '.') 
			{
				c = read();
				double m = 1;
				while (!isSpaceChar(c)) 
				{
					if (c == 'e' || c == 'E')
						return res * Math.pow(10, nextInt());
					if (c < '0' || c > '9')
						throw new InputMismatchException();
					m /= 10;
					res += (c - '0') * m;
					c = read();
				}
			}
			return res * sgn;
		}
		
		public String readString() 
		{
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuilder res = new StringBuilder();
			do 
			{
				res.appendCodePoint(c);
				c = read();
			} 
			while (!isSpaceChar(c));
			
			return res.toString();
		}
	 
		public boolean isSpaceChar(int c) 
		{
			if (filter != null)
				return filter.isSpaceChar(c);
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}
	 
		public String next() 
		{
			return readString();
		}
		
		public interface SpaceCharFilter 
		{
			public boolean isSpaceChar(int ch);
		}
	}
	
	static class Node implements Comparable<Node>
	{
		int value;
		int id;
		
		public Node(int value,int id)
		{
			this.value=value;
			this.id=id;
		}
		
		public int compareTo(Node node)
		{
			if(value<node.value)
				return 1;
			
			if(value>node.value)
				return -1;
			
			if(id<node.id)
				return 1;
			
			return -1;
		}
	}
	
	public static void updateBinaryIndexedTree(int binaryIndexedTree[], int val, int index)
	{
		if(val%2 != 1)
		{
			while(val%2 != 1)
			{
				val /= 2;
			}
		}
		
        while(index < binaryIndexedTree.length)
		{
            binaryIndexedTree[index] ^= val;
            index = getNext(index);
        }
    }
    
    public static int getSum(int binaryIndexedTree[], int index)
	{
        index = index + 1;
        int sum = 0;
		
        while(index > 0)
		{
            sum ^= binaryIndexedTree[index];
            index = getParent(index);
        }
        return sum;
    }
    
    public static int[] createTree(int input[])
	{
        int binaryIndexedTree[] = new int[input.length+10];
		
        for(int i=1; i <= input.length; i++)
		{
            updateBinaryIndexedTree(binaryIndexedTree, input[i-1], i);
        }
        return binaryIndexedTree;
    }
    
    public static int getParent(int index)
	{
        return index - (index & -index);
    }
    
    public static int getNext(int index)
	{
        return index + (index & -index);
    }
	
	public static void main(String args[]) throws Exception
	{	
		InputReader  In = new InputReader(System.in);
		PrintWriter w=new PrintWriter(System.out);
		 
		String S = In.next();
		
		char arr[] = S.toCharArray();
		
		int ans = 0 , Ans = 0;
		
		for(int i = 0 ; i < arr.length ; i++)
		{
			if(arr[i] != 'A' && arr[i] != 'E' &&  arr[i] != 'I' &&  arr[i] != 'O' && arr[i] != 'U' && arr[i] != 'Y')
				ans++;
			else
			{
				Ans = Math.max(Ans , ans);
				ans = 0;
			}
		}
		Ans = Math.max(Ans , ans);
		
		w.println(Ans+1);
		
		w.close();
	}
}