Problem: Having read half of the book called "Storm and Calm" on the IT lesson, Innocentius was absolutely determined to finish the book on the maths lessons. All was fine until the math teacher Ms. Watkins saw Innocentius reading fiction books instead of solving equations of the fifth degree. As during the last maths class Innocentius suggested the algorithm of solving equations of the fifth degree in the general case, Ms. Watkins had no other choice but to give him a new task.

The teacher asked to write consecutively (without spaces) all words from the "Storm and Calm" in one long string s. She thought that a string is good if the number of vowels in the string is no more than twice more than the number of consonants. That is, the string with v vowels and c consonants is good if and only if v ≤ 2c.

The task Innocentius had to solve turned out to be rather simple: he should find the number of the longest good substrings of the string s.

Input

The only input line contains a non-empty string s consisting of no more than 2·105 uppercase and lowercase Latin letters. We shall regard letters "a", "e", "i", "o", "u" and their uppercase variants as vowels.

Output

Print on a single line two numbers without a space: the maximum length of a good substring and the number of good substrings with this length. If no good substring exists, print "No solution" without the quotes.

Two substrings are considered different if their positions of occurrence are different. So if some string occurs more than once, then it should be counted more than once.

Examples

Input

Abo


Output

3 1


Input

OEIS


Output

3 1


Input

auBAAbeelii


Output

9 3


Input

AaaBRAaaCAaaDAaaBRAaa


Output

18 4


Input

EA


Output

No solution

Note

In the first sample there is only one longest good substring: "Abo" itself. The other good substrings are "b", "Ab", "bo", but these substrings have shorter length.

In the second sample there is only one longest good substring: "EIS". The other good substrings are: "S", "IS".

Solution (in JAVA):

Solution:
import java.io.*;
import java.util.*;

public class tr1 {
	static PrintWriter out;
	static StringBuilder sb;
	static int inf = (int) 1e9;
	static int mod = (int) 1e9 + 7;
	static int[] si;
	static ArrayList<Integer> primes;
	static HashSet<Integer> pr;
	static int n;
	static boolean [] in;
	static HashMap<Integer,Integer> factors;
	public static void main(String[] args) throws IOException {
		Scanner sc = new Scanner(System.in);
		out = new PrintWriter(System.out);
	    String s=sc.next();
	    int n=s.length();
	    int N=1;
	    while(N<n)
	    	N<<=1;
	    HashSet<Character> h=new HashSet<>();
	    h.add('a');
	    h.add('e');
	    h.add('u');
	    h.add('i');
	    h.add('o');
	    s=s.toLowerCase();
	    int []a=new int[N+1];
	    for(int i=0;i<n;i++) {
	    	if(h.contains(s.charAt(i)))
	    		a[i+1]=-1;
	    	else
	    		a[i+1]=2;
	    }
	    int sum=0;
	   int []aa=new int [n];
	   int maxlength=0;
	   for(int i=1;i<=n;i++) {
		   aa[i-1]=a[i];
		   if(a[i]==2)
			   sum=1;
	   }
	//   System.out.println(Arrays.toString(longestSubarray(aa)));
	   int []r=longestSubarray(aa);
	 // System.out.println(Arrays.toString((aa)));
	  //System.out.println(Arrays.toString((r)));
               maxlength=r[1]-r[0]+1;	   
	  //  System.out.println(maxlength+" "+Arrays.toString(a)+" "+n);
              if(sum==0)
            	  maxlength=0;
	    if(maxlength==0) {
	    	System.out.println("No solution");
	    	return;
	    }
	    int num=0;
	    segmentTree st=new segmentTree(a);
	    for(int i=1;i+maxlength-1<=n;i++) {
	    	int q=st.query(i, i+maxlength-1);
	    	if(q>=0)
	    		num++;
	    }
	    out.print(maxlength+" "+num);
		out.flush();
	}
	  public static int[] longestSubarray(int[] inp) {
		    // array containing prefix sums up to a certain index i
		    int[] p = new int[inp.length];
		    p[0] = inp[0];
		    for (int i = 1; i < inp.length; i++) {
		      p[i] = p[i - 1] + inp[i];
		    }

		    // array Q from the description below
		    int[] q = new int[inp.length];
		    q[inp.length - 1] = p[inp.length - 1];
		    for (int i = inp.length - 2; i >= 0; i--) {
		      q[i] = Math.max(q[i + 1], p[i]);
		    }

		    int a = 0;
		    int b = 0;
		    int maxLen = 0;
		    int curr;
		    int[] res = new int[] {-1,-1};
		    while (b < inp.length) {
		      curr = a > 0 ? q[b] - p[a-1] : q[b];
		      if (curr >= 0) {
		        if(b-a > maxLen) {
		          maxLen = b-a;
		          res = new int[] {a,b};
		        }
		        b++;
		      } else {
		        a++;
		      }
		    }
		    return res;
		  }
	   static void factor(int n) {
		   if(si[n]==n) {
			   factors.put(n, factors.getOrDefault(n, 0)+1);
			   return;
		   }
		   factors.put(si[n], factors.getOrDefault(si[n], 0)+1);
		   factor(n/si[n]);
	   }
	static void seive() {
		 si=new int [1000001];
		    primes=new ArrayList<>();
		    int N=1000001;
		    pr=new HashSet<>();
		    si[1]=1;
		    for(int i=2;i<N;i++) {
		    	if(si[i]==0) {
		    		si[i]=i;
		    		primes.add(i);
		    		pr.add(i);
		    	}
		    	for(int j=0;j<primes.size() && primes.get(j)<=si[i] && (i*primes.get(j))<N;j++)
		    		si[primes.get(j)*i]=
		    		primes.get(j);
		    		
		    }
	}
	static public class segmentTree {
		int[] array, tree, lazy;
		int n;

		segmentTree(int[] aa) {
			array = aa;
			n = array.length - 1;
			tree = new int[n * 4];
			lazy = new int[n * 4];
			Arrays.fill(lazy, -1);
			build(1, 1, n);
		}

		public String toString() {
			return Arrays.toString(tree);
		}

		void build(int node, int l, int r) {
			if (l == r)
				tree[node] = array[r];
			else {
				int mid = (l + r) >> 1;
				build(node << 1, l, mid);
				build((node << 1) | 1, mid + 1, r);
				tree[node] = tree[node << 1] + tree[node << 1 | 1];
			}
		}

		void updateRange(int i, int j, int v) {
			updateR(1, 1, n, i, j, v);
		}

		void updateR(int node, int l, int r, int i, int j, int v) {
			if (i > r || j < l)
				return;
			if (i <= l && j >= r) {
				tree[node] = (r - l + 1) * v;
				lazy[node] = v;
			} else {
				int mid = l + r >> 1;
				propagate(node, l, mid, r);
				updateR(node << 1, l, mid, i, j, v);
				updateR(node << 1 | 1, mid + 1, r, i, j, v);
				tree[node] = tree[node << 1] + tree[node << 1 | 1];
			}
		}

		void propagate(int node, int b, int mid, int e) {
			if (lazy[node] != -1) {
				lazy[node << 1] = lazy[node];
				lazy[node << 1 | 1] = lazy[node];
				tree[node << 1] = (mid - b + 1) * lazy[node];
				tree[node << 1 | 1] = (e - mid) * lazy[node];
			}
			lazy[node] = -1;
		}

		int query(int i, int j) {
			return query(1, 1, n, i, j);
		}

		int query(int node, int b, int e, int i, int j) // O(log n)
		{
			if (i > e || j < b)
				return 0;
			if (b >= i && e <= j)
				return tree[node];
			int mid = b + e >> 1;
		//	propagate(node, b, mid, e);
			int q1 = query(node << 1, b, mid, i, j);
			int q2 = query(node << 1 | 1, mid + 1, e, i, j);
			return q1 + q2;

		}

	}

	static class pair2 implements Comparable<pair2> {
		int x;
		int idx;

		pair2(int x, int d) {
			this.x = x;
			//this.y = y;
			idx = d;
		}

		public String toString() {
			return x + " " + idx;
		}

		@Override
		public int compareTo(pair2 o) {
			if (o.x == x)
				return idx - o.idx;
			return o.x - x;
		}
	}

	static class pair implements Comparable<pair> {
		int x;
		int y;

		pair(int x, int y) {
			this.x = x;
			this.y = y;
		}

		public String toString() {
			return x + " " + y;
		}

		@Override
		public int compareTo(pair o) {
			if (o.x == x)
				return o.y - y;
			return x - o.x;
		}
	}

	static int gcd(int a, int b) {

		if (b == 0) {
			return a;
		}
		return gcd(b, a % b);
	}

	static class unionfind {
		int[] p;
		int[] size;

		unionfind(int n) {
			p = new int[n];
			size = new int[n];

			for (int i = 0; i < n; i++) {
				p[i] = i;
			}
			Arrays.fill(size, 1);
		}

		int findSet(int v) {
			if (v == p[v])
				return v;
			return p[v] = findSet(p[v]);
		}

		boolean sameSet(int a, int b) {
			a = findSet(a);
			b = findSet(b);
			if (a == b)
				return true;
			return false;
		}

		int max() {
			int max = 0;
			for (int i = 0; i < size.length; i++)
				if (size[i] > max)
					max = size[i];
			return max;
		}

		void combine(int a, int b) {
			a = findSet(a);
			b = findSet(b);
			if (a == b)
				return;
			if (size[a] > size[b]) {
				p[b] = a;
				size[a] += size[b];

			} else {
				p[a] = b;
				size[b] += size[a];
			}
		}
	}

	static class Scanner {
		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream system) {
			br = new BufferedReader(new InputStreamReader(system));
		}

		public Scanner(String file) throws Exception {
			br = new BufferedReader(new FileReader(file));
		}

		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

		public String nextLine() throws IOException {
			return br.readLine();
		}

		public int nextInt() throws IOException {
			return Integer.parseInt(next());
		}

		public double nextDouble() throws IOException {
			return Double.parseDouble(next());
		}

		public char nextChar() throws IOException {
			return next().charAt(0);
		}

		public Long nextLong() throws IOException {
			return Long.parseLong(next());
		}

		public boolean ready() throws IOException {
			return br.ready();
		}

		public void waitForInput() throws InterruptedException {
			Thread.sleep(3000);
		}
	}
}