You're given an array a_1, …, a_n of n non-negative integers.

Let's call it sharpened if and only if there exists an integer 1 ≤ k ≤ n such that a_1 < a_2 < … < a_k and a_k > a_{k+1} > … > a_n. In particular, any strictly increasing or strictly decreasing array is sharpened. For example:

  * The arrays [4], [0, 1], [12, 10, 8] and [3, 11, 15, 9, 7, 4] are sharpened; 
  * The arrays [2, 8, 2, 8, 6, 5], [0, 1, 1, 0] and [2, 5, 6, 9, 8, 8] are not sharpened. 



You can do the following operation as many times as you want: choose any strictly positive element of the array, and decrease it by one. Formally, you can choose any i (1 ≤ i ≤ n) such that a_i>0 and assign a_i := a_i - 1.

Tell if it's possible to make the given array sharpened using some number (possibly zero) of these operations.

Input

The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 15\ 000) — the number of test cases. The description of the test cases follows.

The first line of each test case contains a single integer n (1 ≤ n ≤ 3 ⋅ 10^5).

The second line of each test case contains a sequence of n non-negative integers a_1, …, a_n (0 ≤ a_i ≤ 10^9).

It is guaranteed that the sum of n over all test cases does not exceed 3 ⋅ 10^5.

Output

For each test case, output a single line containing "Yes" (without quotes) if it's possible to make the given array sharpened using the described operations, or "No" (without quotes) otherwise.

Example

Input


10
1
248618
3
12 10 8
6
100 11 15 9 7 8
4
0 1 1 0
2
0 0
2
0 1
2
1 0
2
1 1
3
0 1 0
3
1 0 1


Output


Yes
Yes
Yes
No
No
Yes
Yes
Yes
Yes
No

Note

In the first and the second test case of the first test, the given array is already sharpened.

In the third test case of the first test, we can transform the array into [3, 11, 15, 9, 7, 4] (decrease the first element 97 times and decrease the last element 4 times). It is sharpened because 3 < 11 < 15 and 15 > 9 > 7 > 4.

In the fourth test case of the first test, it's impossible to make the given array sharpened.
#include<bits/stdc++.h>
#define ll long long
#define li long long
#define ull unsigned long long
#define pb push_back
#define ins insert
#define er erase
#define f(i,a,b) for(li i=a;i<b;++i)
#define rf(i,a,b) for(i=a;i>=b;--i)
#define tc int t;cin>>t;while(t--)
#define fast ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define vi vector<int>
#define vll vector<ll>
#define vull vector<ull>
#define vc vector<char>
#define vst vector<string>
#define bs bitset
#define mp make_pair
#define ff first
#define ss second
#define pii pair<int ,int>
#define pll pair<ll,ll>
#define mll map<ll,ll>
#define umll unordered_map<ll,ll>
#define pqi priority_queue<int>
#define pqll priority_queue<ll>
#define all(v) v.begin(),v.end()
#define gcd(a,b) __gcd(a,b)
#define lcm(a,b) (a*b)/gcd(a,b)
#define lb lower_bound
#define ub upper_bound
#define mxe max_element
#define mne min_element
#define nl "\n"
#define sp " "

using namespace std;

#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;

#define ordered_set tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
#define ok order_of_key
#define fo find_by_order

ll md=1000*1000*1000+7;

//const ll N=1e5;

ll pw(ll a, ll b){
    ll c=1, m=a;
    while(b){
        if(b&1)c=(c*m)%md;
        m=(m*m)%md;b/=2;
    }
    return c;
}

ll mmi(ll a)
{ 
    ll inverse = pw(a, md-2); // 
    return inverse ;
}

 bool prime(ll n)
 {
     if(n==2)return true;
     if(!(n%2))
         return false;
     else{
         for(ll i=3;i<n;i+=2)
         {
             if(!(n%i))
                 return false;
         }
     }
return true;
 }
 ll mult(li a,li b)
 {
     return ((a%md)*(b%md))%md;
 }
 ll add(li a,li b)
 {return (a+b)%md;}
 ll sub(li a,li b)
 {return (a-b)%md;}
/* Segment Tree
const int N=100000
///  size of segment tree 
//ll n; // array size 
  
// Max size of tree 
//ll tree[2 * N]; 
  
 
void build( ll arr[])  
{   
    for (ll i=0; i<n; i++)     
        tree[n+i] = arr[i];    
    for (ll i = n - 1; i > 0; --i)      
        tree[i] = tree[i<<1] + tree[i<<1 | 1];     
} 
  
//function to update a tree node at pth index
void updateTreeNode(ll p, ll value)  
{   
    tree[p+n] = value; 
    p = p+n;
    for (ll i=p; i > 1; i >>= 1) 
        tree[i>>1] = tree[i] + tree[i^1]; 
} //function to get sum on interval [l,r)
ll query(ll l, ll r)  
{  
    ll res = 0; for (l += n, r += n; l < r; l >>= 1, r >>= 1) 
    { 
        if (l&1)  
            res += tree[l++];
        if (r&1)  
            res += tree[--r]; 
    } return res; 
} 
*//*
// Returns value of Binomial Coefficient C(n, k) 
ll nCr(ll n, ll k) 
{ ll C[n + 1][k + 1],i,j; 
    for (i = 0; i <= n; i++) 
    {for (j = 0; j <= min(i, k); j++) {
            if (j == 0 || j == i) 
                C[i][j] = 1; 
            else      C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]);   } 
  }  return C[n][k]; 
} 

//UF

class UF    {
public:
    int *id, cnt, *sz;
 
    // Create an empty union find data structure with N isolated sets.
    UF(int N)   {
        cnt = N;
    id = new int[N];
    sz = new int[N];
        for(int i=0; i<N; i++)    {
            id[i] = i;
        sz[i] = 1;
    }
    }
    ~UF()    {
    delete [] id;
    delete [] sz;
    }
    // Return the id of component corresponding to object p.
    int find(int p)    {
        int root = p;
        while (root != id[root])
            root = id[root];
        while (p != root) {
            int newp = id[p];
            id[p] = root;
            p = newp;
        }
        return root;
    }
    // Replace sets containing x and y with their union.
    void merge(int x, int y)    {
        int i = find(x);
        int j = find(y);
        if (i == j) return;
        
        // make smaller root point to larger one
        if   (sz[i] < sz[j])    { 
        id[i] = j; 
        sz[j] += sz[i]; 
    } else    { 
        id[j] = i; 
        sz[i] += sz[j]; 
    }
        cnt--;
    }
    // Are objects x and y in the same set?
    bool connected(int x, int y)    {
        return find(x) == find(y);
    }
    // Return the number of disjoint sets.
    int count() {
        return cnt;
    }
 
};


 
 Trie implementation 
const int MAX =31;
class Trie
{
    public:
    bool isend;
    Trie *child[31];
    Trie()
    {
        isend=false;
        f(i,0,31)
        child[i]=NULL;
    }
};

Trie *root =new Trie();

void insert(Trie *root,ll m)
{
     Trie*curr = root;vll v;
    while(m)
    {
        v.pb(m%2);m/=2;
    }
    reverse(all(v));
    while(v.size()!=MAX)v.insert(v.begin(),0);
    for(int i=0;i<v.size();i++)
    {
        ll index=v[i];
        //{cout<<index;}
        if(curr->child[index]==NULL)
        curr->child[index]=new Trie();
        curr=curr->child[index];
    }
    curr->isend=true;
}

ll maxn(Trie *root,ll m)
{
     Trie*curr = root;vll v;
    while(m)
    {
        v.pb(m%2);m/=2;
    }
    reverse(all(v));vll v1;
    while(v.size()!=MAX)v.insert(v.begin(),0);
    for(int i=0;i<v.size();i++)
    {
        ll index=v[i];
        if(curr->child[1-index]==NULL){v1.pb(0);curr=curr->child[1-index];}
        else curr=curr->child[1-index];

    }
    ll ans=0;ll pr=pow(2,30);
    for(int i=0;i<31;i++)
    {
      ans+=v[i]*pr;
      pr/=2;
    }
    return ans;
}

bool isempty(Trie *root)
{
    for(ll i=0;i<MAX;i++)
    {if(root->child[i]!=NULL)
    return false;}
    return true;
}

Trie *delete(Trie*root,string &key,ll i)
{
    if(root ==  NULL) return NULL;
    if(i==key.length())
    {
        root->isend=false;
        if(isempty(root)==true)
        {delete(root);root = NULL;}
        return root;
    }
    int index = key[i]-'a';
    root->child[index]=delete(root->child[index],key,i+1);
    if(isempty(root)&&root->isend==false)
    {delete(root);root=NULL;}
    return root;
}
 

// Kruskal implementation

const int MAX = 1e4 + 5;
int id[MAX], nodes, edges;
pair <long long, pair<int, int> > p[MAX];

void initialize()
{
    for(int i = 0;i < MAX;++i)
        id[i] = i;
}

int root(int x)
{
    while(id[x] != x)
    {
        id[x] = id[id[x]];
        x = id[x];
    }
    return x;
}

void union1(int x, int y)
{
    int p = root(x);
    int q = root(y);
    id[p] = id[q];
}

long long kruskal(pair<long long, pair<int, int> > p[])
{
    int x, y;
    long long cost, minimumCost = 0;
    for(int i = 0;i < edges;++i)
    {
        // Selecting edges one by one in increasing order from the beginning
        x = p[i].second.first;
        y = p[i].second.second;
        cost = p[i].first;
        // Check if the selected edge is creating a cycle or not
        if(root(x) != root(y))
        {
            minimumCost += cost;
            union1(x, y);
        }    
    }
    return minimumCost;
}

//Prim's Implementation
const int MAX = 1e4 + 5;
typedef pair<long long, int> PII;
bool marked[MAX];
vector <PII> adj[MAX];

long long prim(int x)
{
    priority_queue<PII, vector<PII>, greater<PII> > Q;
    int y;
    long long minimumCost = 0;
    PII p;
    Q.push(make_pair(0, x));
    while(!Q.empty())
    {
        // Select the edge with minimum weight
        p = Q.top();
        Q.pop();
        x = p.second;
        // Checking for cycle
        if(marked[x] == true)
            continue;
        minimumCost += p.first;
        marked[x] = true;
        for(int i = 0;i < adj[x].size();++i)
        {
            y = adj[x][i].second;
            if(marked[y] == false)
                Q.push(adj[x][i]);
        }
    }
    return minimumCost;
}

Floyd Warshall Algorithm
for(int k = 1; k <= n; k++){
    for(int i = 1; i <= n; i++){
        for(int j = 1; j <= n; j++){
            dist[i][j] = min( dist[i][j], dist[i][k] + dist[k][j] );
        }
    }
}

// C++ program to do range minimum query 
// using sparse table 
#include <bits/stdc++.h> 
using namespace std; 
#define MAX 500 
  
// lookup[i][j] is going to store minimum 
// value in arr[i..j]. Ideally lookup table 
// size should not be fixed and should be 
// determined using n Log n. It is kept 
// constant to keep code simple. 
int lookup[MAX][MAX]; 
  
// Fills lookup array lookup[][] in bottom up manner. 
void buildSparseTable(int arr[], int n) 
{ 
    // Initialize M for the intervals with length 1 
    for (int i = 0; i < n; i++) 
        lookup[i][0] = arr[i]; 
  
    // Compute values from smaller to bigger intervals 
    for (int j = 1; (1 << j) <= n; j++) { 
  
        // Compute minimum value for all intervals with 
        // size 2^j 
        for (int i = 0; (i + (1 << j) - 1) < n; i++) { 
  
            // For arr[2][10], we compare arr[lookup[0][7]]  
            // and arr[lookup[3][10]] 
            if (lookup[i][j - 1] <  
                        lookup[i + (1 << (j - 1))][j - 1]) 
                lookup[i][j] = lookup[i][j - 1]; 
            else
                lookup[i][j] =  
                         lookup[i + (1 << (j - 1))][j - 1]; 
        } 
    } 
} 
  
// Returns minimum of arr[L..R] 
int query(int L, int R) 
{ 
    // Find highest power of 2 that is smaller 
    // than or equal to count of elements in given 
    // range. For [2, 10], j = 3 
    int j = (int)log2(R - L + 1); 
  
    // Compute minimum of last 2^j elements with first 
    // 2^j elements in range. 
    // For [2, 10], we compare arr[lookup[0][3]] and 
    // arr[lookup[3][3]], 
    if (lookup[L][j] <= lookup[R - (1 << j) + 1][j]) 
        return lookup[L][j]; 
  
    else
        return lookup[R - (1 << j) + 1][j]; 
} 
  

 */
/*
ll N=1000001;
int is_prime[N];

bool sieve() {
    // We cross out all composites from 2 to sqrt(N)
    ll i=2;
    // This will loop from 2 to int(sqrt(x))
    while(i*i <= N) {
        // If we already crossed out this number, then continue
        if(is_prime[i] == 0) {
            i++;
            continue;
        }
        int j = 2*i;
        while(j < N) {
            // Cross out this as it is composite
            is_prime[j] = 0;
            // j is incremented by i, because we want to cover all multiples of i
            j += i;
        }
        i++;
    }
}
//Matrix Exponentiation

// C++ program to find value of f(n) where f(n) 
// is defined as 
//    F(n) = F(n-1) + F(n-2) + F(n-3), n >= 3 
// Base Cases : 
//    F(0) = 0, F(1) = 1, F(2) = 1 
#include<bits/stdc++.h> 
using namespace std; 
  
// A utility function to multiply two matrices 
// a[][] and b[][].  Multiplication result is 
// stored back in b[][] 
void multiply(int a[3][3], int b[3][3]) 
{ 
    // Creating an auxiliary matrix to store elements  
    // of the multiplication matrix 
    int mul[3][3]; 
    for (int i = 0; i < 3; i++) 
    { 
        for (int j = 0; j < 3; j++) 
        { 
            mul[i][j] = 0; 
            for (int k = 0; k < 3; k++) 
                mul[i][j] += a[i][k]*b[k][j]; 
        } 
    } 
  
    // storing the multiplication result in a[][] 
    for (int i=0; i<3; i++) 
        for (int j=0; j<3; j++) 
            a[i][j] = mul[i][j];  // Updating our matrix 
} 
  
// Function to compute F raise to power n-2. 
int power(int F[3][3], int n) 
{ 
    int M[3][3] = {{1,1,1}, {1,0,0}, {0,1,0}}; 
  
    // Multiply it with initial values i.e with 
    // F(0) = 0, F(1) = 1, F(2) = 1 
    if (n==1) 
        return F[0][0] + F[0][1]; 
  
    power(F, n/2); 
  
    multiply(F, F); 
  
    if (n%2 != 0) 
        multiply(F, M); 
  
    // Multiply it with initial values i.e with 
    // F(0) = 0, F(1) = 1, F(2) = 1 
    return F[0][0] + F[0][1] ; 
} 
  
// Return n'th term of a series defined using below 
// recurrence relation. 
// f(n) is defined as 
//    f(n) = f(n-1) + f(n-2) + f(n-3), n>=3 
// Base Cases : 
//    f(0) = 0, f(1) = 1, f(2) = 1 
int findNthTerm(int n) 
{ 
  
    int F[3][3] = {{1,1,1}, {1,0,0}, {0,1,0}} ; 
  
    //Base cases 
    if(n==0) 
        return 0; 
    if(n==1 || n==2) 
        return 1; 
  
    return power(F, n-2); 
} 


ll mygc(ll a,ll b)
{
    if(a==0)return b;
    else return mygc(b%a,a);
}

ll phi(ll k)
{   ll k1=k;
    if(!(k%2))k1-=k1/2;
    while(!(k%2))k/=2;
    f(i,3,sqrt(k)+1)
    {
        if(!(k%i))k1-=k1/i;
        while(!(k%i))k/=i;
    }
    if(k>2)k1-=k1/k;
    return k1;
}

// Typical segment tree for minimium range and range update using lazy propagation
ll n;
//Remember here k=>(l,r) means k>=l and k<r.
ll const N = 200099;
ll p[N];
ll a[N];
ll ind[N];
ll t[4*N];
ll add[4*N];
ll b[N];


void build(ll v,ll l,ll r)
{
if((r-l)==1)
{
    t[v]=b[l];
    return;
}
ll mid=(l+r)/2;
build(2*v+1,l,mid);
build(2*v+2,mid,r);
t[v]=min(t[2*v+1],t[2*v+2]);
}

void push(ll v,ll l,ll r)
{
    if(add[v]!=0)
    {
        if(r-l>1)
      f(i,v+v+1,v+v+3)
      {
          add[i]+=add[v];
          t[i]+=add[v];
      }
      add[v]=0;
    }
}

void upd(ll v,ll l, ll r, ll L,ll R,ll x)
{   
    if(L>=R)return ;
   if(l==L && r==R)
   {
       t[v]+=x;
       add[v]+=x;
       push(v,l,r);
       return;
   }
   push(v,l,r);
   ll mid =(l+r)/2;
   upd(2*v+1,l, mid,L,min(mid,R), x);
   upd( 2*v+2, mid,r, max(mid,L), R, x);
   t[v]=min(t[2*v+1],t[2*v+2]);
}

void upd(ll l,ll r, ll x)
{
 upd(0,0,n,l,r,x);
}

ll get(ll v,ll l,ll r,ll L,ll R)
{
    if(L>=R)return 1e18;
    push(v,l,r);
    if(l==L && (r)==R)
    return t[v];
    ll mid=(l+r)/2;
    return min(get(2*v+1,l,mid,L,min(R,mid)),get(2*v+2,mid,r,max(L,mid),R));
}

ll get(ll l,ll r)
{
    return get(0,0,n,l,r);
}

// C++ program for implementation of KMP pattern searching 
// algorithm 

  
void computeLPSArray(char* pat, int M, int* lps); 
  
// Prints occurrences of txt[] in pat[] 
void KMPSearch(char* pat, char* txt) 
{ 
    int M = strlen(pat); 
    int N = strlen(txt); 
  
    // create lps[] that will hold the longest prefix suffix 
    // values for pattern 
    int lps[M]; 
  
    // Preprocess the pattern (calculate lps[] array) 
    computeLPSArray(pat, M, lps); 
  
    int i = 0; // index for txt[] 
    int j = 0; // index for pat[] 
    while (i < N) { 
        if (pat[j] == txt[i]) { 
            j++; 
            i++; 
        } 
  
        if (j == M) { 
            printf("Found pattern at index %d ", i - j); 
            j = lps[j - 1]; 
        } 
  
        // mismatch after j matches 
        else if (i < N && pat[j] != txt[i]) { 
            // Do not match lps[0..lps[j-1]] characters, 
            // they will match anyway 
            if (j != 0) 
                j = lps[j - 1]; 
            else
                i = i + 1; 
        } 
    } 
} 
  
// Fills lps[] for given patttern pat[0..M-1] 
void computeLPSArray(char* pat, int M, int* lps) 
{ 
    // length of the previous longest prefix suffix 
    int len = 0; 
  
    lps[0] = 0; // lps[0] is always 0 
  
    // the loop calculates lps[i] for i = 1 to M-1 
    int i = 1; 
    while (i < M) { 
        if (pat[i] == pat[len]) { 
            len++; 
            lps[i] = len; 
            i++; 
        } 
        else // (pat[i] != pat[len]) 
        { 
            // This is tricky. Consider the example. 
            // AAACAAAA and i = 7. The idea is similar 
            // to search step. 
            if (len != 0) { 
                len = lps[len - 1]; 
  
                // Also, note that we do not increment 
                // i here 
            } 
            else // if (len == 0) 
            { 
                lps[i] = 0; 
                i++; 
            } 
        } 
    } 
} 

*/


int main()
{
tc{
    ll n;cin>>n;vll v(n);
    f(i,0,n)cin>>v[i];bool ok=false;
    f(i,0,n)
    {
      if(v[i]>=max(i,n-1-i)){ok=true;break;}
    }
    if(ok)cout<<"Yes"<<nl;
    else cout<<"No"<<nl;
}
}
