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.lang.Math;
import java.util.*;

public class cddd {

	//static long[] ar= new long[1000000001];
	static final FastScanner sc= new FastScanner();
	static final Random random= new Random();
	static int[] gen(int n) {
        int [] ran = new int[n];
        for(int i=0;i<n;i++) {
            ran[i] = random.nextInt((int)1e9);
        }
        return ran;
    }
	public static void main(String args[]) throws IOException {
		int t=sc.nextInt();
		for(int q=0;q<t;q++) {
			String a=sc.next();
			int n=a.length();
			int l=n-1;
		    int m=0;
		    boolean f=false;
		    int i=0;
		    while(i<n) {
		        if (a.charAt(i)=='a'){
		            f=true;
		            l=i;
		            m=i-1;}
		        i+=1;}
		    int r=0;
		    while(m>=0 || l<n) {
		        if(l<n && a.charAt(l)=='a'+r) l+=1;
		        else if(m>=0 && a.charAt(m)=='a'+r) m-=1;
		        else {f=false;
		            break;}
		        r++;
		 }
		    if(f) System.out.println("YES");
		    else System.out.println("NO");
	}
}}


class FastScanner
{
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer str = new StringTokenizer("");

    String next() throws IOException {
        while(!str.hasMoreTokens())
            str = new StringTokenizer(br.readLine());

        return str.nextToken();
    }

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

    int nextInt() throws IOException {

        return Integer.parseInt(next());
    }

    float nextfloat() throws IOException
    {
        return Float.parseFloat(next());
    }

    double nextDouble() throws IOException
    {
        return Double.parseDouble(next());
    }
    long nextLong() throws IOException
    {
        return Long.parseLong(next());
    }
    byte nextByte() throws IOException
    {
        return Byte.parseByte(next());
    }
    int [] arrayIn(int n) throws IOException {
        int  arr[] = new int[n];
        for(int i=0; i<n; i++)
        {
            arr[i] = nextInt();
        }
        return arr;
    }
}

class Graph{
	ArrayList<ArrayList<Integer>> graph;
	int V;
	Graph(int nodes){
		V= nodes;
		graph= new ArrayList<ArrayList<Integer>>();
		for (int i=0;i<V;i++) {
			graph.add(new ArrayList<Integer>());
		}
	}
	void addEdge(int v, int u) {
		graph.get(v).add(u);
		graph.get(u).add(v);
	}
	
	void printGraph() {
		for(int i=0;i<V;i++) {
			System.out.print("Node "+i);
			for (int x:graph.get(i)) System.out.print("-> "+x);
		}
	}
	
	void DFSval(int node,boolean visited[]) {
		visited[node]=true;
		//System.out.println(node+" );
		for(int x:graph.get(node)) {
			if(visited[x]==false) {
				DFSval(x,visited);
			}
		}
	}
	
	void DFS(int start) {
		boolean visited []= new boolean[V];
		DFSval(start,visited);
		
	}
	
	void BFS(int start) {
		boolean visited[]= new boolean [V];
		Queue<Integer> q=new LinkedList<Integer>();
		q.add(start);
		visited[start]=true;
		while(q.isEmpty()==false) {
			int node=q.poll();
			//System.out.println(node+" ");
			for( int x:graph.get(node)) {
				if(visited[x]==false) {
					if(visited[x]==false) {
						visited[x]=true;
						q.add(x);
					}
				}
			}
		}
	}
}

// waste code
/*
for(int i=0;i<n;i++) {
    int j,k;
    for(j=i-1;j>=i-x&&j>=0;j--) {
        if(arr[i] > arr[j]) break;
    }
    for(k=i+1;k<=i+y&&k<n;k++) {
        if(arr[i] > arr[k]) break;
    }
    if(j<=0 || (i-j-1)>=x) {
        if(k>=n || (k-i-1)>=y) {
            System.out.println(i+1);
            return;
        }
    }
 
}*/