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.BufferedReader;
	import java.io.IOException;
	import java.io.InputStreamReader;
	import java.util.ArrayDeque;
	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.Collections;
	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.List;
	import java.util.Map;
	import java.util.Set;
	import java.util.StringTokenizer;
	import java.util.TreeMap;
	 
	public class CSES {
		static long check(long n) {
			for(int i=2;i*i<=n;i++) {
				if(n%i==0)return i;
			}
			return -1;
		}
		public static void main(String[] args) throws IOException {
			FastScanner s=new FastScanner();
			int t = s.nextInt();
			while(t-->0) {
				String se  =s.next();
				char[] a = se.toCharArray();
				int[] cnt = new int[50];
				boolean f=true;
				for(char i:a) {
					cnt[(int)(i-'a')]=1;
				}
				for(int i=0;i<se.length();i++) {
					if(cnt[i]!=1)f=false;
				}
				for(int i=1;i<a.length-1;i++) {
					if((int)(a[i]-'a') > (int)(a[i-1]-'a') && (int)(a[i]-'a') >(int)(a[i+1]-'a')) {
						f=false;
						break;
					}
				}
				System.out.println(f?"YES":"NO");
			}
		}
	    static int lower_bound(int[] arr, int x) {
	        int low_limit = 0, high_limit = arr.length, mid = -1;
	        while (low_limit < high_limit) {
	            mid = (low_limit + high_limit) / 2;
	            if (arr[mid] >= x){
	                high_limit = mid;
	            }else{
	                low_limit = mid + 1;
	            }
	        }
	        return low_limit+1;
	    }
		static long gcd(long a, long b)throws IOException{return (b==0)?a:gcd(b,a%b);}
	    static int gcd(int a, int b)throws IOException{return (b==0)?a:gcd(b,a%b);}
	    
	    static void sortr(int[] a) {
			ArrayList<Integer> l=new ArrayList<>();
			for (int i:a) l.add(i);
			Collections.sort(l,Collections.reverseOrder());
			for (int i=0; i<a.length; i++) a[i]=l.get(i);
		}
		static void sort(int[] a) {
			ArrayList<Integer> l=new ArrayList<>();
			for (int i:a) l.add(i);
			Collections.sort(l);
			for (int i=0; i<a.length; i++) a[i]=l.get(i);
		}
		static void sort(long[] a) {
			ArrayList<Long> l=new ArrayList<>();
			for (long i:a) l.add(i);
			Collections.sort(l);
			for (int i=0; i<a.length; i++) a[i]=l.get(i);
		}
		static class FastScanner {
			BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
			StringTokenizer st=new StringTokenizer("");
			String next() {
				while (!st.hasMoreTokens())
					try {
						st=new StringTokenizer(br.readLine());
					} catch (IOException e) {
						e.printStackTrace();
					}
				return st.nextToken();
			}
			
			int nextInt() {
				return Integer.parseInt(next());
			}
			int[] readArray(int n) {
				int[] a=new int[n];
				for (int i=0; i<n; i++) a[i]=nextInt();
				return a;
			}
			long nextLong() {
				return Long.parseLong(next());
			}
		}
	}
