A string s of length n (1 ≤ n ≤ 26) is called alphabetical if it can be obtained using the following algorithm:

  * first, write an empty string to s (i.e. perform the assignment s := ""); 
  * then perform the next step n times; 
  * at the i-th step take i-th lowercase letter of the Latin alphabet and write it either to the left of the string s or to the right of the string s (i.e. perform the assignment s := c+s or s := s+c, where c is the i-th letter of the Latin alphabet). 



In other words, iterate over the n first letters of the Latin alphabet starting from 'a' and etc. Each time we prepend a letter to the left of the string s or append a letter to the right of the string s. Strings that can be obtained in that way are alphabetical.

For example, the following strings are alphabetical: "a", "ba", "ab", "bac" and "ihfcbadeg". The following strings are not alphabetical: "z", "aa", "ca", "acb", "xyz" and "ddcba".

From the given string, determine if it is alphabetical.

Input

The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.

Each test case is written on a separate line that contains one string s. String s consists of lowercase letters of the Latin alphabet and has a length between 1 and 26, inclusive.

Output

Output t lines, each of them must contain the answer to the corresponding test case. Output YES if the given string s is alphabetical and NO otherwise.

You can output YES and NO in any case (for example, strings yEs, yes, Yes and YES will be recognized as a positive answer).

Example

Input


11
a
ba
ab
bac
ihfcbadeg
z
aa
ca
acb
xyz
ddcba


Output


YES
YES
YES
YES
YES
NO
NO
NO
NO
NO
NO

Note

The example contains test cases from the main part of the condition.
import java.io.*;
import java.util.*;
public class B {
    public static void main(String args[])throws IOException{
        FastReader sc = new FastReader();
        PrintWriter out = new PrintWriter(System.out);
        int t = sc.nextInt();
        while(t-- > 0){
			String s = sc.next();
			int ind_curr = -1;
			for(int i = 0; i < s.length(); i++) {
				if(s.charAt(i) == 'a') {
					ind_curr = i;
					break;
				}
			}
			if(ind_curr == -1) {
				out.println("NO");
				continue;
			}
			int left = ind_curr-1;
			int right = ind_curr+1;
			char curr_char = 'b';
			int flag = 1;
			while(left >= 0 || right < s.length()) {
				flag = 0;
				if(left >= 0 && s.charAt(left) == curr_char) {
					left--;
					curr_char += 1;
					flag = 1;
				}
				else if(right < s.length() && s.charAt(right) == curr_char) {
					right++;
					curr_char += 1;
					flag = 1;
				}
				else {
					break;
				}
				// out.println(left + ", " + right);
			}
			if(flag == 0) {
				out.println("NO");
			}
			else {
				out.println("YES");
			}
		}
        out.flush();
    }
    static class FastReader {
		BufferedReader br;
		StringTokenizer st;

		public FastReader()
		{
			br = new BufferedReader(
				new InputStreamReader(System.in));
		}

		String next()
		{
			while (st == null || !st.hasMoreElements()) {
				try {
					st = new StringTokenizer(br.readLine());
				}
				catch (IOException e) {
					e.printStackTrace();
				}
			}
			return st.nextToken();
		}

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

		long nextLong() { return Long.parseLong(next()); }

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

		String nextLine()
		{
			String str = "";
			try {
				str = br.readLine();
			}
			catch (IOException e) {
				e.printStackTrace();
			}
			return str;
		}
	}

	static void swap(long[] arr, int i, int j)
	{
		long temp = arr[i];
		arr[i] = arr[j];
		arr[j] = temp;
	}
	
	/* This function takes last element as pivot, places
	the pivot element at its correct position in sorted
	array, and places all smaller (smaller than pivot)
	to left of pivot and all greater elements to right
	of pivot */
	static int partition(long[] arr, int low, int high)
	{
		
		// pivot
		long pivot = arr[high];
		
		// Index of smaller element and
		// indicates the right position
		// of pivot found so far
		int i = (low - 1);
	
		for(int j = low; j <= high - 1; j++)
		{
			
			// If current element is smaller
			// than the pivot
			if (arr[j] < pivot)
			{
				
				// Increment index of
				// smaller element
				i++;
				swap(arr, i, j);
			}
		}
		swap(arr, i + 1, high);
		return (i + 1);
	}
	
	/* The main function that implements QuickSort
			arr[] --> Array to be sorted,
			low --> Starting index,
			high --> Ending index
	*/
	static void quickSort(long[] arr, int low, int high)
	{
		if (low < high)
		{
			
			// pi is partitioning index, arr[p]
			// is now at right place
			int pi = partition(arr, low, high);
	
			// Separately sort elements before
			// partition and after partition
			quickSort(arr, low, pi - 1);
			quickSort(arr, pi + 1, high);
		}
	}
}