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.
#include <bits/stdc++.h>

using namespace std;

const long long mod = 1e9 + 7;

long long add(long long a, long long b) {
    long long res = a + b;
    if (res >= mod) res -= mod;
    return res;
}

long long sub(long long a, long long b) {
    long long res = a - b + mod;
    if (res >= mod) res -= mod;
    return res;
}

long long mul(long long a, long long b) {
    return (((a % mod) * (b % mod)) % mod);
}

long long potolok(long long a, long long b){
    return (a + b - 1) / b;
}

long long gcd(long long x, long long y){
    if(y == 0){
        return x;
    }
    if(x == 0){
        return y;
    }
    if(x > y){
         return gcd(y, x % y);
    }
    else{
         return gcd(x, y % x);
    }
}

long long bin_pow(long long base, long long power){
    if(power == 1){
        return base;
    }
    if(power % 2 == 0){
        long long t = bin_pow(base, power / 2);
        return t * t;
    }
    else{
        return bin_pow(base, power - 1) * base;
    }
}

struct segtree{

    int razmer;

    vector<long long> tree;

    void Init(vector<long long> &v){
        int n = (int)v.size();
        razmer = 1;
        while(razmer < n) razmer *= 2;
        tree.assign(2 * razmer - 1, 0);
    }

    void build(vector<long long> &v, int x, int lx, int rx){
        if(rx - lx == 1){
            if(lx < (int)v.size()){
                tree[x] = v[lx];
            }
        }else{
            int m = (lx + rx) / 2;
            build(v, 2 * x + 1, lx, m);
            build(v, 2 * x + 2, m, rx);
            tree[x] = min(tree[2 * x + 1], tree[2 * x + 2]);
        }
    }

    void build(vector<long long> &v){
        build(v, 0, 0, razmer);
    }

    void cet(int i, int v, int x, int lx, int rx){
        if(rx - lx == 1){
            tree[x] = v;
            return;
        }else{
            int m = (lx + rx) / 2;
            if(i < m){
                cet(i, v, 2 * x + 1, lx, m);
            }else{
                cet(i, v, 2 * x + 2, m, rx);
            }
            tree[x] = min(tree[2 * x + 1], tree[2 * x + 2]);
        }
    }

    void cet(int i, int v){
        cet(i, v, 0, 0, razmer);
    }

    long long mn(int l, int r, int x, int lx, int rx){
        if(lx >= r || l >= rx){
            return mod;
        }
        if(lx >= l && rx <= r){
            return tree[x];
        }
        else if(min(rx, r) - max(lx, l) >= 0){
            int m = (lx + rx) / 2;
            long long s1 = mn(l, r, 2 * x + 1, lx, m);
            long long s2 = mn(l, r, 2 * x + 2, m, rx);
            return min(s1, s2);
        }
    }

    long long mn(int l, int r){
        return mn(l, r, 0, 0, razmer);
    }

};

bool isSquare(int x) {
	int y = (int)(sqrt(x));
	while(y * y < x) y++;
	while(y * y > x) y--;
	return y * y == x;
}

void solve(){
    string s;
    cin >> s;
    int n = (int)s.size();
    map<char, int> mp;
    for(auto i : s){
        mp[i]++;
        if(mp[i] > 1){
            cout << "No" << endl;
            return;
        }
    }
    for(int i = 0;i < n;i++){
        if(s[i] - 'a' >= n){
            cout << "No" << endl;
            return;
        }
    }
    int start = -1;
    for(int i = 0;i < n;i++){
        if(s[i] == 'a')start = i;
    }
    if(start == -1){
        cout << "No" << endl;
        return;
    }
    for(int i = 0;i < start;i++){
        for(int j = i + 1;j < start;j++){
            if(s[i] < s[j]){// ihfcbadeg
                cout << "No" << endl;
                return;
            }
        }
    }
    for(int i = start + 1;i < n;i++){
        for(int j = start + 1;j < i;j++){
            if(s[i] < s[j]){
                    cout << "No" << endl;
                return;
            }
        }
    }
    cout << "Yes" << endl;
}

int main(){
    int t;
    //t = 1;
    cin >> t;
    while(t--){
        solve();
    }
    return 0;
}

