Let's call left cyclic shift of some string t_1 t_2 t_3 ... t_{n - 1} t_n as string t_2 t_3 ... t_{n - 1} t_n t_1.

Analogically, let's call right cyclic shift of string t as string t_n t_1 t_2 t_3 ... t_{n - 1}.

Let's say string t is good if its left cyclic shift is equal to its right cyclic shift.

You are given string s which consists of digits 0–9.

What is the minimum number of characters you need to erase from s to make it good?

Input

The first line contains single integer t (1 ≤ t ≤ 1000) — the number of test cases.

Next t lines contains test cases — one per line. The first and only line of each test case contains string s (2 ≤ |s| ≤ 2 ⋅ 10^5). Each character s_i is digit 0–9.

It's guaranteed that the total length of strings doesn't exceed 2 ⋅ 10^5.

Output

For each test case, print the minimum number of characters you need to erase from s to make it good.

Example

Input


3
95831
100120013
252525252525


Output


3
5
0

Note

In the first test case, you can erase any 3 characters, for example, the 1-st, the 3-rd, and the 4-th. You'll get string 51 and it is good.

In the second test case, we can erase all characters except 0: the remaining string is 0000 and it's good.

In the third test case, the given string s is already good.

	
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.*;

import java.io.*;
	

	
public class Main {
	static InputReader obj = new InputReader(System.in);
	static long mod = (long)1e9+7;
	public static void main(String args[]) {
		main();
	}
	
	static void main() {
		int t=obj.nextInt();
		// StringBuilder ans = new StringBuilder();
		while(t-->0) {
			char arr[] = obj.next().toCharArray();
			int n=arr.length;
			int cnt[]=new int[10];
			for(int i=0;i<n;i++) {
				cnt[arr[i]-'0']++;
			}
			int min=n;
			for(int i=0;i<10;i++) {
				for(int j=0;j<10;j++) {
					if(i==j) continue;
					int x=f(arr,i,j);
					min=Math.min(min, n-x);
				}
			}
			
			for(int i=0;i<10;i++) {
				min = Math.min(min, n-cnt[i]);
			}
			System.out.println(min);
		}
		
	}
	
	public static int f(char arr[], int x, int y) {
		int ans=0;
		int n=arr.length;
		for(int i=0;i<n;i++) {
			if(ans%2==1) {
				if(arr[i]==y+'0') ans++;
			}
			else {
				if(arr[i]==x+'0') ans++;
			}
		}
		ans-=ans%2;
		return ans;
	}
	public static void rev(char a[], int k) {
		int n=a.length;
		for(int i=0;i<=k/2;i++) {
			char temp=a[i];
			a[i] = (char)('1'+'0'-a[k-i]);
			a[k-i] = (char)('1'+'0'-temp);
		}
	}
	
	public static void input(int arr[], int n) {
		for(int i=0;i<n;i++) {
	    	arr[i] = obj.nextInt();
	    }
	}
	
	public static class InputReader {
	    public BufferedReader reader;
	    public StringTokenizer tokenizer;
	    public InputReader(InputStream stream) {
	        reader = new BufferedReader(new InputStreamReader(stream), 32768);
	        tokenizer = null;
	    }
 
	    public String next() {
	        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
	            try {
	                tokenizer = new StringTokenizer(reader.readLine());
	            } catch (IOException e) {
	                throw new RuntimeException(e);
	            }
	        }
	        return tokenizer.nextToken();
	    }
 
	    public int nextInt() {
	        return Integer.parseInt(next());
	    }
 
	    public long nextLong() {
	        return Long.parseLong(next());
	    }
	}

}
