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.*;
import java.io.*;

public class Solution{
	public Solution(){
		Scanner sc = new Scanner(System.in);
		String n = sc.next();
		int max = 0;
		int last = 0;
		
		int index = 0;
		while(index != -1){
			index = indexOfVowel(n, last);
			if(index != -1){
				int jump = index - last + 1;
				last = index + 1;
				if(jump > max){
					max = jump;
				}
			}
		}
		
		int jump = n.length() - last + 1;
		if(jump > max){
			max = jump;
		}
		
		System.out.println(max);
	}
	
	int indexOfVowel(String str, int start){
		if(start >= str.length()){
			return -1;
		}
		
		int minIndex = str.indexOf('A', start);
		int index = str.indexOf('E', start);
		
		if(minIndex == -1 || index < minIndex){
			if(index != -1){
				minIndex = index;
			}
		}
		
		index = str.indexOf('I', start);
		
		if(minIndex == -1 || index < minIndex){
			if(index != -1){
				minIndex = index;
			}
		}
		
		index = str.indexOf('O', start);
		
		if(minIndex == -1 || index < minIndex){
			if(index != -1){
				minIndex = index;
			}
		}
		
		index = str.indexOf('U', start);
		
		if(minIndex == -1 || index < minIndex){
			if(index != -1){
				minIndex = index;
			}
		}
		
		index = str.indexOf('Y', start);
		
		if(minIndex == -1 || index < minIndex){
			if(index != -1){
				minIndex = index;
			}
		}
		
		return minIndex;
	}
	
	int binarySearch(int arr[], int l, int r, int x) 
    { 
        if (r >= l) { 
            int mid = l + (r - l) / 2; 
  
            // If the element is present at the 
            // middle itself 
            if (arr[mid] == x) 
                return mid; 
  
            // If element is smaller than mid, then 
            // it can only be present in left subarray 
            if (arr[mid] > x) 
                return binarySearch(arr, l, mid - 1, x); 
  
            // Else the element can only be present 
            // in right subarray 
            return binarySearch(arr, mid + 1, r, x); 
        } 
  
        // We reach here when element is not present 
        // in array 
        return -1; 
    }
	
	int partition(int arr[], int[] dep, int low, int high) 
    { 
        int pivot = arr[high];  
        int i = (low-1); // index of smaller element 
        for (int j=low; j<high; j++) 
        { 
            // If current element is smaller than or 
            // equal to pivot 
            if (arr[j] <= pivot) 
            { 
                i++; 
  
                // swap arr[i] and arr[j] 
                int temp = arr[i]; 
                arr[i] = arr[j]; 
                arr[j] = temp;
				
				if(dep != null){
					temp = dep[i];
					dep[i] = dep[j];
					dep[j] = temp;
				}
            } 
        } 
  
        // swap arr[i+1] and arr[high] (or pivot) 
        int temp = arr[i+1]; 
        arr[i+1] = arr[high]; 
        arr[high] = temp;
		
		if(dep != null){
			temp = dep[i+1];
			dep[i+1] = dep[high];
			dep[high] = temp;
		}
  
        return i+1; 
    } 
  
  
    /* The main function that implements QuickSort() 
      arr[] --> Array to be sorted, 
      low  --> Starting index, 
      high  --> Ending index */
    void sort(int arr[], int[] dep, int low, int high) 
    { 
        if (low < high) 
        { 
            /* pi is partitioning index, arr[pi] is  
              now at right place */
            int pi = partition(arr, dep, low, high); 
  
            // Recursively sort elements before 
            // partition and after partition 
            sort(arr, dep, low, pi-1); 
            sort(arr, dep, pi+1, high); 
        } 
    }
	
	public static void main(String[] args){
		new Solution();
	}
}